|
Freeciv-3.3
|
Go to the source code of this file.
Data Structures | |
| struct | unit_ai |
| struct | unit_type_ai |
Macros | |
| #define | WAR(plr1, plr2) (player_diplstate_get(plr1, plr2)->type == DS_WAR) |
| #define | NEVER_MET(plr1, plr2) (player_diplstate_get(plr1, plr2)->type == DS_NO_CONTACT) |
| #define | DEFENSE_POWER(ptype) (ptype->defense_strength * ptype->hp * ptype->firepower) |
| #define | ATTACK_POWER(ptype) (ptype->attack_strength * ptype->hp * ptype->firepower) |
| #define | IS_ATTACKER(ptype) (ptype->attack_strength > ptype->transport_capacity) |
| #define | POTENTIALLY_HOSTILE_PLAYER(ait, pplayer, aplayer) |
| #define | UNITTYPE_COSTS(ut) |
| #define | INVASION_OCCUPY 0 |
| #define | INVASION_ATTACK 1 |
| #define | RAMPAGE_ANYTHING 1 |
| #define | RAMPAGE_HUT_OR_BETTER 99998 |
| #define | RAMPAGE_FREE_CITY_OR_BETTER 99999 |
| #define | BODYGUARD_RAMPAGE_THRESHOLD (SHIELD_WEIGHTING * 4) |
| #define | simple_ai_unit_type_iterate(_ut) |
| #define | simple_ai_unit_type_iterate_end |
Enumerations | |
| enum | ai_unit_task { AIUNIT_NONE , AIUNIT_AUTO_WORKER , AIUNIT_BUILD_CITY , AIUNIT_DEFEND_HOME , AIUNIT_ATTACK , AIUNIT_ESCORT , AIUNIT_EXPLORE , AIUNIT_RECOVER , AIUNIT_HUNTER , AIUNIT_TRADE , AIUNIT_WONDER } |
Variables | |
| struct unit_type * | simple_ai_types [U_LAST] |
| #define BODYGUARD_RAMPAGE_THRESHOLD (SHIELD_WEIGHTING * 4) |
| #define NEVER_MET | ( | plr1, | |
| plr2 | |||
| ) | (player_diplstate_get(plr1, plr2)->type == DS_NO_CONTACT) |
| #define WAR | ( | plr1, | |
| plr2 | |||
| ) | (player_diplstate_get(plr1, plr2)->type == DS_WAR) |
In the words of Syela: "Using funky fprime variable instead of f in the denom, so that def=1 units are penalized correctly."
Translation (GB): build_cost_balanced is used in the denominator of the want equation (see, e.g. find_something_to_kill) instead of just build_cost to make AI build more balanced units (with def > 1).
Definition at line 250 of file daiunit.c.
Referenced by dai_evaluate_tile_for_air_attack(), find_something_to_kill(), and process_attacker_want().
| bool dai_can_unit_type_follow_unit_type | ( | const struct unit_type * | follower, |
| const struct unit_type * | followee, | ||
| struct ai_type * | ait | ||
| ) |
See if the follower can follow the followee
Definition at line 835 of file daiunit.c.
Referenced by look_for_charge(), and process_attacker_want().
| void dai_consider_tile_dangerous | ( | struct ai_type * | ait, |
| struct tile * | ptile, | ||
| struct unit * | punit, | ||
| enum override_bool * | result | ||
| ) |
Are there dangerous enemies at or adjacent to the tile 'ptile'?
Always override advisor danger detection since we are omniscient and advisor is not.
Definition at line 3127 of file daiunit.c.
Referenced by cai_consider_tile_dangerous(), and texwai_consider_tile_dangerous().
Decide what to do with a military unit. It will be managed once only. It is up to the caller to try again if it has moves left.
Definition at line 2505 of file daiunit.c.
Referenced by dai_manage_paratrooper(), and dai_manage_unit().
manage one unit Careful: punit may have been destroyed upon return from this routine!
Gregor: This function is a very limited approach because if a unit has several flags the first one in order of appearance in this function will be used.
Definition at line 2660 of file daiunit.c.
Referenced by dai_manage_barbarian_leader(), and dai_manage_units().
Master manage unit function.
A manage function should set the unit to 'done' when it should no longer be touched by this code, and its role should be reset to IDLE when its role has accomplished its mission or the manage function fails to have or no longer has any use for the unit.
Definition at line 2867 of file daiunit.c.
Referenced by dai_do_first_activities().
Find and kill anything reachable within this turn and worth more than the relevant of the given thresholds until we have run out of juicy targets or movement. The first threshold is for attacking which will leave us where we stand (attacking adjacent units), the second is for attacking distant (but within reach) targets.
For example, if unit is a bodyguard on duty, it should call dai_military_rampage(punit, 100, RAMPAGE_FREE_CITY_OR_BETTER) meaning "we will move _only_ to pick up a free city but we are happy to attack adjacent squares as long as they are worthy of it".
Returns TRUE if survived the rampage session.
Definition at line 601 of file daiunit.c.
Referenced by dai_manage_hitpoint_recovery(), dai_manage_paratrooper(), dai_military_attack(), dai_military_bodyguard(), and dai_military_defend().
| struct unit_type * dai_role_utype_for_terrain_class | ( | struct city * | pcity, |
| int | role, | ||
| enum terrain_class | tc | ||
| ) |
Get unit type player can build, suitable to role, with given move type.
Definition at line 3439 of file daiunit.c.
Referenced by contemplate_terrain_improvements(), and dai_city_choose_build().
| void dai_switch_to_explore | ( | struct ai_type * | ait, |
| struct unit * | punit, | ||
| struct tile * | target, | ||
| enum override_bool * | allow | ||
| ) |
Switch to autoexploring.
Definition at line 3483 of file daiunit.c.
Referenced by cai_switch_to_explore(), and texwai_switch_to_explore().
Returns whether 'attacker' can attack 'defender' immediately.
Definition at line 3450 of file daiunit.c.
Referenced by dai_hunter_try_launch().
Free unit from use with default AI.
Definition at line 3351 of file daiunit.c.
Referenced by cai_unit_close(), and texwai_unit_free().
Initialize unit for use with default AI.
Definition at line 3317 of file daiunit.c.
Referenced by cai_unit_init(), and texwai_unit_alloc().
| void dai_unit_load | ( | struct ai_type * | ait, |
| const char * | aitstr, | ||
| const struct section_file * | file, | ||
| struct unit * | punit, | ||
| const char * | unitstr | ||
| ) |
Load AI data of a unit.
Definition at line 3388 of file daiunit.c.
Referenced by cai_unit_load(), and texwai_unit_load().
| void dai_unit_save | ( | struct ai_type * | ait, |
| const char * | aitstr, | ||
| struct section_file * | file, | ||
| const struct unit * | punit, | ||
| const char * | unitstr | ||
| ) |
Save AI data of a unit.
Definition at line 3369 of file daiunit.c.
Referenced by cai_unit_save(), and texwai_unit_save().
Free unit from use with default AI.
Definition at line 3339 of file daiunit.c.
Referenced by cai_unit_turn_end(), and texwai_unit_turn_end().
Close AI unit type data
Definition at line 3299 of file daiunit.c.
Referenced by cai_units_ruleset_close(), and texwai_units_ruleset_close().
Initialise the unit data from the ruleset for the AI.
Definition at line 3208 of file daiunit.c.
Referenced by cai_units_ruleset_init(), and texwai_units_ruleset_init().
| bool find_beachhead | ( | const struct player * | pplayer, |
| struct pf_map * | ferry_map, | ||
| struct tile * | dest_tile, | ||
| const struct unit_type * | cargo_type, | ||
| const struct unit_type * | ferry_type, | ||
| struct tile ** | ferry_dest, | ||
| struct tile ** | beachhead_tile | ||
| ) |
Returns TRUE if a beachhead has been found to reach 'dest_tile'.
Definition at line 1062 of file daiunit.c.
Referenced by find_something_to_kill(), and process_attacker_want().
Find safe city to recover in. An allied player's city is just as good as one of our own, since both replenish our hitpoints and reduce unhappiness.
TODO: Actually check how safe the city is. This is a difficult decision not easily taken, since we also want to protect unsafe cities, at least most of the time.
Definition at line 1636 of file daiunit.c.
Referenced by dai_find_boat_for_unit(), dai_manage_hitpoint_recovery(), dai_manage_paratrooper(), and dai_military_attack().
| adv_want find_something_to_kill | ( | struct ai_type * | ait, |
| struct player * | pplayer, | ||
| struct unit * | punit, | ||
| struct tile ** | pdest_tile, | ||
| struct pf_path ** | ppath, | ||
| struct pf_map ** | pferrymap, | ||
| struct unit ** | pferryboat, | ||
| const struct unit_type ** | pboattype, | ||
| int * | pmove_time | ||
| ) |
Find something to kill! This function is called for units to find targets to destroy and for cities that want to know if they should build offensive units. Target location returned in 'dest_tile', want as function return value.
punit->id == 0 means that the unit is virtual (considered to be built).
Definition at line 1140 of file daiunit.c.
Referenced by dai_military_attack(), and kill_something_with().
Compute how much we want to kill certain victim we've chosen, counted in SHIELDs.
FIXME?: The equation is not accurate as the other values can vary for other victims on same tile (we take values from best defender) - however I believe it's accurate just enough now and lost speed isn't worth that. –pasky
Benefit is something like 'attractiveness' of the victim, how nice it would be to destroy it. Larger value, worse loss for enemy.
Attack is the total possible attack power we can throw on the victim. Note that it usually comes squared.
Loss is the possible loss when we would lose the unit we are attacking with (in SHIELDs).
Vuln is vulnerability of our unit when attacking the enemy. Note that it usually comes squared as well.
Victim count is number of victims stacked in the target tile. Note that we shouldn't treat cities as a stack (despite the code using this function) - the scaling is probably different. (extremely dodgy usage of it – GB)
Definition at line 342 of file daiunit.c.
Referenced by dai_evaluate_tile_for_air_attack(), find_something_to_kill(), and process_attacker_want().
| adv_want look_for_charge | ( | struct ai_type * | ait, |
| struct player * | pplayer, | ||
| struct unit * | punit, | ||
| struct unit ** | aunit, | ||
| struct city ** | acity | ||
| ) |
See if we can find something to defend. Called both by wannabe bodyguards and building want estimation code. Returns desirability for using this unit as a bodyguard or for defending a city.
We do not consider units with higher movement than us, or units that are native to terrains or extras not native to us, as potential charges. Nor do we attempt to bodyguard units with higher defense than us, or military units with lower attack than us that are not transports.
Definition at line 715 of file daiunit.c.
Referenced by dai_military_findjob(), and dai_unit_consider_bodyguard().
| bool uclass_need_trans_between | ( | struct unit_class * | pclass, |
| struct tile * | ctile, | ||
| struct tile * | ptile | ||
| ) |
If a unit of pclass needs some transport or road to go from ctile to ptile, maybe omitting way ends. Maybe it should return fc_tristate?
This depends on wld.map, cannot be used for determining situation in other maps.
Definition at line 1949 of file daiunit.c.
Referenced by dai_caravan_goto(), and dai_manage_caravan().
| int unittype_def_rating_squared | ( | const struct unit_type * | att_type, |
| const struct unit_type * | def_type, | ||
| struct player * | def_player, | ||
| struct tile * | ptile, | ||
| bool | fortified, | ||
| int | veteran | ||
| ) |
Defense rating of def_type unit against att_type unit, squared. See get_virtual_defense_power() for the arguments att_type, def_type, x, y, fortified and veteran.
Definition at line 304 of file daiunit.c.
Referenced by find_something_to_kill(), kill_something_with(), and process_attacker_want().
| const struct impr_type * utype_needs_improvement | ( | const struct unit_type * | putype, |
| const struct city * | pcity | ||
| ) |
Returns an improvement that will make it possible to build units of the specified type the specified city. Returns NULL if no new improvement will make it possible or if no improvement is needed.
Definition at line 2902 of file daiunit.c.
Referenced by dai_wants_defender_against(), dai_wants_role_unit(), and process_attacker_want().
1.9.8