/**************************************************************************
Do sanity checks on a guard, reporting error messages to the log
if necessary.
Inconsistent references do not always indicate an error, because units
can change owners (for example, because of civil war) outside the control
the the AI code.
**************************************************************************/
void aiguard_check_guard(const struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
const struct unit *charge_unit = game_unit_by_number(guard_data->charge);
const struct city *charge_city = game_city_by_number(guard_data->charge);
const struct player *guard_owner = unit_owner(guard);
const struct player *charge_owner = NULL;
struct unit_ai *charge_data = NULL;
fc_assert_ret(BODYGUARD_NONE <= guard_data->charge);
/* IDs always distinct */
fc_assert_ret(charge_unit == NULL || charge_city == NULL);
if (charge_unit) {
charge_owner = unit_owner(charge_unit);
charge_data = def_ai_unit_data(charge_unit);
} else if (charge_city) {
charge_owner = city_owner(charge_city);
}
if (charge_unit && charge_data->bodyguard != guard->id) {
BODYGUARD_LOG(LOG_DEBUG, guard, "inconsistent guard references");
} else if (!charge_unit && !charge_city && 0 < guard_data->charge) {
BODYGUARD_LOG(LOG_DEBUG, guard, "dangling guard reference");
}
if (charge_owner && pplayers_at_war(charge_owner, guard_owner)) {
/* Probably due to civil war */
BODYGUARD_LOG(LOG_DEBUG, guard, "enemy charge");
} else if (charge_owner && charge_owner != guard_owner) {
/* Probably sold a city with its supported units. */
BODYGUARD_LOG(LOG_DEBUG, guard, "foreign charge");
}
}
/**************************************************************************
Check whether the assignment of a guard is still sane, and fix and problems.
It was once sane, but might have been destroyed or become an enemy since.
**************************************************************************/
void aiguard_update_charge(struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
const struct unit *charge_unit = game_unit_by_number(guard_data->charge);
const struct city *charge_city = game_city_by_number(guard_data->charge);
const struct player *guard_owner = unit_owner(guard);
const struct player *charge_owner = NULL;
fc_assert_ret(BODYGUARD_NONE <= guard_data->charge);
/* IDs always distinct */
fc_assert_ret(charge_unit == NULL || charge_city == NULL);
if (charge_unit) {
charge_owner = unit_owner(charge_unit);
} else if (charge_city) {
charge_owner = city_owner(charge_city);
}
if (!charge_unit && !charge_city && 0 < guard_data->charge) {
guard_data->charge = BODYGUARD_NONE;
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "charge was destroyed");
}
if (charge_owner && charge_owner != guard_owner) {
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "charge transferred, dismiss");
aiguard_clear_charge(guard);
}
CHECK_GUARD(guard);
}
/****************************************************************************
Return color for overview map tile.
****************************************************************************/
static struct color *overview_tile_color(struct tile *ptile)
{
if (overview.layers[OLAYER_CITIES]) {
struct city *pcity = tile_city(ptile);
if (pcity) {
if (NULL == client.conn.playing
|| city_owner(pcity) == client.conn.playing) {
return get_color(tileset, COLOR_OVERVIEW_MY_CITY);
} else if (pplayers_allied(city_owner(pcity), client.conn.playing)) {
/* Includes teams. */
return get_color(tileset, COLOR_OVERVIEW_ALLIED_CITY);
} else {
return get_color(tileset, COLOR_OVERVIEW_ENEMY_CITY);
}
}
}
if (overview.layers[OLAYER_UNITS]) {
struct unit *punit = find_visible_unit(ptile);
if (punit) {
if (NULL == client.conn.playing
|| unit_owner(punit) == client.conn.playing) {
return get_color(tileset, COLOR_OVERVIEW_MY_UNIT);
} else if (pplayers_allied(unit_owner(punit), client.conn.playing)) {
/* Includes teams. */
return get_color(tileset, COLOR_OVERVIEW_ALLIED_UNIT);
} else {
return get_color(tileset, COLOR_OVERVIEW_ENEMY_UNIT);
}
}
}
if (overview.layers[OLAYER_BORDERS]) {
struct player *owner = tile_owner(ptile);
if (owner) {
if (overview.layers[OLAYER_BORDERS_ON_OCEAN]) {
return get_player_color(tileset, owner);
} else if (!is_ocean_tile(ptile)) {
return get_player_color(tileset, owner);
}
}
}
if (overview.layers[OLAYER_RELIEF] && tile_terrain(ptile) != T_UNKNOWN) {
return get_terrain_color(tileset, tile_terrain(ptile));
}
if (overview.layers[OLAYER_BACKGROUND] && tile_terrain(ptile) != T_UNKNOWN) {
if (is_ocean_tile(ptile)) {
return get_color(tileset, COLOR_OVERVIEW_OCEAN);
} else {
return get_color(tileset, COLOR_OVERVIEW_LAND);
}
}
return get_color(tileset, COLOR_OVERVIEW_UNKNOWN);
}
/*****************************************************************************
Find best tile the paratrooper should jump to.
*****************************************************************************/
static struct tile *find_best_tile_to_paradrop_to(struct ai_type *ait,
struct unit *punit)
{
int best = 0;
int val;
struct tile* best_tile = NULL;
int range = unit_type(punit)->paratroopers_range;
struct city* acity;
struct player* pplayer = unit_owner(punit);
/* First, we search for undefended cities in danger */
square_iterate(unit_tile(punit), range, ptile) {
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) {
val = city_size_get(acity) * def_ai_city_data(acity, ait)->urgency;
if (val > best) {
best = val;
best_tile = ptile;
}
}
} square_iterate_end;
if (best_tile != NULL) {
acity = tile_city(best_tile);
UNIT_LOG(LOGLEVEL_PARATROOPER, punit,
"Choose to jump in order to protect allied city %s (%d %d). "
"Benefit: %d",
city_name(acity), TILE_XY(best_tile), best);
return best_tile;
}
/* Second, we search for undefended enemy cities */
square_iterate(unit_tile(punit), range, ptile) {
acity = tile_city(ptile);
if (acity && pplayers_at_war(unit_owner(punit), city_owner(acity)) &&
(unit_list_size(ptile->units) == 0)) {
if (!map_is_known_and_seen(ptile, pplayer, V_MAIN)
&& ai_handicap(pplayer, H_FOG)) {
continue;
}
/* Prefer big cities on other continents */
val = city_size_get(acity)
+ (tile_continent(unit_tile(punit)) != tile_continent(ptile));
if (val > best) {
best = val;
best_tile = ptile;
}
}
} square_iterate_end;
/**************************************************************************
Looks for nearest airbase for punit reachable imediatly.
Returns NULL if not found. The path is stored in the path
argument if not NULL.
TODO: Special handicaps for planes running out of fuel
IMO should be less restrictive than general H_MAP, H_FOG
*************************************************************************/
static struct tile *find_nearest_airbase(const struct unit *punit,
struct pf_path **path)
{
struct player *pplayer = unit_owner(punit);
const struct unit_type *punittype = unit_type(punit);
struct pf_parameter parameter;
struct pf_map *pfm;
pft_fill_unit_parameter(¶meter, punit);
pfm = pf_map_new(¶meter);
pf_map_move_costs_iterate(pfm, ptile, move_cost, TRUE) {
if (move_cost > punit->moves_left) {
/* Too far! */
break;
}
if (is_airunit_refuel_point(ptile, pplayer, punittype, FALSE)) {
if (path) {
*path = pf_map_path(pfm, ptile);
}
pf_map_destroy(pfm);
return ptile;
}
} pf_map_move_costs_iterate_end;
pf_map_destroy(pfm);
return NULL;
}
/**************************************************************************
Assign a guard to a city.
**************************************************************************/
void aiguard_assign_guard_city(struct city *charge, struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
fc_assert_ret(charge != NULL);
fc_assert_ret(guard != NULL);
/*
* Usually, but not always, city_owner(charge) == unit_owner(guard).
*/
if (0 < guard_data->charge
&& guard_data->charge != charge->id) {
/* Remove previous assignment: */
aiguard_clear_charge(guard);
}
guard_data->charge = charge->id;
if (city_owner(charge) != unit_owner(guard)) {
/* Peculiar, but not always an error */
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "assigned foreign charge");
} else {
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "assigned charge");
}
CHECK_GUARD(guard);
}
/***********************************************************************
Iterates through reachable cities and appraises them as a possible
base for air operations by (air)unit punit. Returns NULL if not
found. The path is stored in the path argument if not NULL.
**********************************************************************/
static struct tile *dai_find_strategic_airbase(struct ai_type *ait,
const struct unit *punit,
struct pf_path **path)
{
struct player *pplayer = unit_owner(punit);
struct pf_parameter parameter;
struct pf_map *pfm;
struct tile *best_tile = NULL;
struct city *pcity;
struct unit *pvirtual = NULL;
int best_worth = 0, target_worth;
pft_fill_unit_parameter(¶meter, punit);
pfm = pf_map_new(¶meter);
pf_map_move_costs_iterate(pfm, ptile, move_cost, FALSE) {
if (move_cost >= punit->moves_left) {
break; /* Too far! */
}
if (!is_airunit_refuel_point(ptile, pplayer,
unit_type(punit), FALSE)) {
continue; /* Cannot refuel here. */
}
if ((pcity = tile_city(ptile))
&& def_ai_city_data(pcity, ait)->grave_danger != 0) {
best_tile = ptile;
break; /* Fly there immediately!! */
}
if (!pvirtual) {
pvirtual =
unit_virtual_create(pplayer,
player_city_by_number(pplayer, punit->homecity),
unit_type(punit), punit->veteran);
}
unit_tile_set(pvirtual, ptile);
target_worth = find_something_to_bomb(ait, pvirtual, NULL, NULL);
if (target_worth > best_worth) {
/* It's either a first find or it's better than the previous. */
best_worth = target_worth;
best_tile = ptile;
/* We can still look for something better. */
}
} pf_map_move_costs_iterate_end;
if (pvirtual) {
unit_virtual_destroy(pvirtual);
}
if (path) {
/* Stores the path. */
*path = best_tile ? pf_map_path(pfm, best_tile) : NULL;
}
pf_map_destroy(pfm);
return best_tile;
}
/**************************************************************************
Assign a bodyguard to a unit.
Assumes that a unit can have at most one guard.
**************************************************************************/
void aiguard_assign_guard_unit(struct unit *charge, struct unit *guard)
{
fc_assert_ret(NULL != charge);
fc_assert_ret(NULL != guard);
fc_assert_ret(charge != guard);
fc_assert_ret(unit_owner(charge) == unit_owner(guard));
/* Remove previous assignment: */
aiguard_clear_charge(guard);
aiguard_clear_guard(charge);
def_ai_unit_data(guard)->charge = charge->id;
def_ai_unit_data(charge)->bodyguard = guard->id;
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "assigned charge");
CHECK_GUARD(guard);
CHECK_CHARGE_UNIT(charge);
}
/**************************************************************************
...
**************************************************************************/
static void sha_unit_new(int id)
{
struct unit *punit = game_find_unit_by_number(id);
struct unit *pold_unit = create_unit_virtual(unit_owner(punit), NULL, 0, 0);
freelog(LOG_DEBUG, "sha got unit: %d", id);
*pold_unit = *punit;
unit_list_prepend(previous_units, pold_unit);
}
/**********************************************************************
Find something to bomb
Air-units specific victim search
Returns the want for the best target. The targets are stored in the
path and pptile arguments if not NULL.
TODO: take counterattack dangers into account
TODO: make separate handicaps for air units seeing targets
IMO should be more restrictive than general H_MAP, H_FOG
*********************************************************************/
static int find_something_to_bomb(struct ai_type *ait, struct unit *punit,
struct pf_path **path, struct tile **pptile)
{
struct player *pplayer = unit_owner(punit);
struct pf_parameter parameter;
struct pf_map *pfm;
struct tile *best_tile = NULL;
int best = 0;
pft_fill_unit_parameter(¶meter, punit);
pfm = pf_map_new(¶meter);
/* Let's find something to bomb */
pf_map_move_costs_iterate(pfm, ptile, move_cost, FALSE) {
if (move_cost >= punit->moves_left) {
/* Too far! */
break;
}
if (ai_handicap(pplayer, H_MAP) && !map_is_known(ptile, pplayer)) {
/* The target tile is unknown */
continue;
}
if (ai_handicap(pplayer, H_FOG)
&& !map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
/* The tile is fogged */
continue;
}
if (is_enemy_unit_tile(ptile, pplayer)
&& dai_should_we_air_attack_tile(ait, punit, ptile)
&& can_unit_attack_tile(punit, ptile)) {
int new_best = dai_evaluate_tile_for_air_attack(punit, ptile);
if (new_best > best) {
best_tile = ptile;
best = new_best;
log_debug("%s wants to attack tile (%d, %d)",
unit_rule_name(punit), TILE_XY(ptile));
}
}
} pf_map_positions_iterate_end;
/* Return the best values. */
if (pptile) {
*pptile = best_tile;
}
if (path) {
*path = best_tile ? pf_map_path(pfm, best_tile) : NULL;
}
pf_map_destroy(pfm);
return best;
}
/**************************************************************************
Do sanity checks on a charge, reporting error messages to the log
if necessary.
Inconsistent references do not always indicate an error, because units
can change owners (for example, because of civil war) outside the control
the the AI code.
**************************************************************************/
void aiguard_check_charge_unit(const struct unit *charge)
{
struct unit_ai *charge_data = def_ai_unit_data(charge);
const struct player *charge_owner = unit_owner(charge);
const struct unit *guard = game_unit_by_number(charge_data->bodyguard);
struct unit_ai *guard_data = NULL;
if (guard) {
guard_data = def_ai_unit_data(guard);
}
fc_assert_ret(guard == NULL
|| (guard_data && BODYGUARD_WANTED <= guard_data->bodyguard));
if (guard && guard_data->charge != charge->id) {
UNIT_LOG(LOG_DEBUG, charge,
"inconsistent guard references");
} else if (guard && unit_owner(guard) != charge_owner) {
UNIT_LOG(LOG_DEBUG, charge, "foreign guard");
}
}
/**************************************************************************
Callack for when user clicks one of the unit icons on left hand side
(units on same square as current unit). Use unit_ids[] data and change
focus to clicked unit.
**************************************************************************/
static void unit_icon_callback(Widget w, XtPointer client_data,
XtPointer call_data)
{
struct unit *punit;
int i = (size_t)client_data;
assert(i>=0 && i<num_units_below);
if (unit_ids[i] == 0) /* no unit displayed at this place */
return;
punit=game_find_unit_by_number(unit_ids[i]);
if(punit) { /* should always be true at this point */
if (unit_owner(punit) == client.conn.playing) {
/* may be non-true if alliance */
set_unit_focus(punit);
}
}
}
/**************************************************************************
Log unit messages, they will appear like this
2: Polish Archers[139] (5,35)->(0,0){0,0} stays to defend city
where [] is unit id, ()->() are coordinates present and goto, and
{,} contains bodyguard and ferryboat ids.
**************************************************************************/
void real_unit_log(const char *file, const char *function, int line,
enum log_level level, bool notify,
const struct unit *punit, const char *msg, ...)
{
char buffer[500];
char buffer2[500];
va_list ap;
int gx, gy;
char aibuf[500] = "\0";
CALL_PLR_AI_FUNC(log_fragment_unit, unit_owner(punit), aibuf, sizeof(aibuf), punit);
if (punit->goto_tile) {
index_to_map_pos(&gx, &gy, tile_index(punit->goto_tile));
} else {
gx = gy = -1;
}
fc_snprintf(buffer, sizeof(buffer),
"%s %s[%d] %s (%d,%d)->(%d,%d){%s} ",
nation_rule_name(nation_of_unit(punit)),
unit_rule_name(punit),
punit->id,
get_activity_text(punit->activity),
TILE_XY(unit_tile(punit)),
gx, gy, aibuf);
va_start(ap, msg);
fc_vsnprintf(buffer2, sizeof(buffer2), msg, ap);
va_end(ap);
cat_snprintf(buffer, sizeof(buffer), "%s", buffer2);
if (notify) {
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buffer);
}
do_log(file, function, line, FALSE, level, "%s", buffer);
}
/**********************************************************************
Returns an estimate for the profit gained through attack.
Assumes that the victim is within one day's flight
**********************************************************************/
static int dai_evaluate_tile_for_air_attack(struct unit *punit,
struct tile *dst_tile)
{
struct unit *pdefender;
/* unit costs in shields */
int balanced_cost, unit_cost, victim_cost = 0;
/* unit stats */
int unit_attack, victim_defence;
/* final answer */
int profit;
/* time spent in the air */
int sortie_time;
#define PROB_MULTIPLIER 100 /* should unify with those in combat.c */
if (!can_unit_attack_tile(punit, dst_tile)
|| !(pdefender = get_defender(punit, dst_tile))) {
return 0;
}
/* Ok, we can attack, but is it worth it? */
/* Cost of our unit */
unit_cost = unit_build_shield_cost(punit);
/* This is to say "wait, ill unit will get better!" */
unit_cost = unit_cost * unit_type(punit)->hp / punit->hp;
/* Determine cost of enemy units */
victim_cost = stack_cost(punit, pdefender);
if (0 == victim_cost) {
return 0;
}
/* Missile would die 100% so we adjust the victim_cost -- GB */
if (uclass_has_flag(unit_class(punit), UCF_MISSILE)) {
victim_cost -= unit_build_shield_cost(punit);
}
unit_attack = (int) (PROB_MULTIPLIER
* unit_win_chance(punit, pdefender));
victim_defence = PROB_MULTIPLIER - unit_attack;
balanced_cost = build_cost_balanced(unit_type(punit));
sortie_time = (unit_has_type_flag(punit, UTYF_ONEATTACK) ? 1 : 0);
profit = kill_desire(victim_cost, unit_attack, unit_cost, victim_defence, 1)
- SHIELD_WEIGHTING + 2 * TRADE_WEIGHTING;
if (profit > 0) {
profit = military_amortize(unit_owner(punit),
game_city_by_number(punit->homecity),
profit, sortie_time, balanced_cost);
log_debug("%s at (%d, %d) is a worthy target with profit %d",
unit_rule_name(pdefender), TILE_XY(dst_tile), profit);
} else {
log_debug("%s(%d, %d): %s at (%d, %d) is unworthy with profit %d",
unit_rule_name(punit), TILE_XY(unit_tile(punit)),
unit_rule_name(pdefender), TILE_XY(dst_tile), profit);
profit = 0;
}
return profit;
}