Freeciv

/* FIXME: try the next action if the unit tried to do an illegal action.

* That would allow the AI to stop using the omniscient

* is_action_enabled_unit_on_*() functions. */

punit, ptile)) {

/* Choose capture. */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_CAPTURE_UNITS);

punit, ptile)) {

/* Choose "Bombard Lethal". */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_BOMBARD_LETHAL);

punit, ptile)) {

/* Choose "Bombard". */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_BOMBARD);

punit, ptile)) {

/* Choose "Bombard 2". */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_BOMBARD2);

punit, ptile)) {

/* Choose "Bombard 3". */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_BOMBARD3);

punit, ptile)) {

/* Choose "Nuke Units". */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

/* Choose "Nuke City". */

unit_do_action(unit_owner(punit), punit->id, tcity->id,

0, "", ACTION_NUKE_CITY);

punit, ptile)) {

/* Choose regular attack. */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

0, "", ACTION_ATTACK);

punit, ptile)) {

/* Choose suicide attack (explode missile). */

unit_do_action(unit_owner(punit), punit->id, tile_index(ptile),

/* Can't be enabled. No target. */

continue;

}

actor_unit, target_tile)) {

return blocker;

}

See note in is_action_enabled() for why the action may still be disabled.

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

const struct unit *actor_unit,

const struct tile *target_tile)

{

return is_action_enabled_unit_on_units_full(nmap, wanted_action, actor_unit,

unit_home(actor_unit),

unit_tile(actor_unit),

const struct unit *actor_unit,

const struct unit *target_unit);

const struct unit *actor_unit,

const struct tile *target_tile);

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

Check if the unit's current activity is actually legal.

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

struct unit *punit)

{

enum unit_activity current = punit->activity;

const struct city *pcity);

bool can_unit_change_homecity(const struct unit *punit);

const char *get_activity_text(enum unit_activity activity);

struct unit *punit);

bool can_unit_do_activity(const struct civ_map *nmap,

const struct unit *punit,

switch (action_id_get_target_kind(act)) {

case ATK_UNITS:

if (tgt_tile

perform_action_to(act, actor, tgt_tile->index, EXTRA_NONE);

}

break;

switch (action_id_get_target_kind(act)) {

case ATK_UNITS:

if (tgt_tile

current = action_prob_vs_units(actor, act, tgt_tile);

}

break;

Action *paction, Tile *tgt)

{

bool enabled = FALSE;

LUASCRIPT_CHECK_STATE(L, FALSE);

LUASCRIPT_CHECK_ARG_NIL(L, punit, 2, Unit, FALSE);

fc_assert_ret_val(action_get_actor_kind(paction) == AAK_UNIT, FALSE);

switch (action_get_target_kind(paction)) {

case ATK_UNITS:

break;

case ATK_TILE:

enabled = is_action_enabled_unit_on_tile(paction->id, punit,

{

struct extra_type *sub_target;

bool enabled = FALSE;

LUASCRIPT_CHECK_STATE(L, FALSE);

LUASCRIPT_CHECK_ARG_NIL(L, punit, 2, Unit, FALSE);

fc_assert_ret_val(action_get_actor_kind(paction) == AAK_UNIT, FALSE);

switch (action_get_target_kind(paction)) {

case ATK_UNITS:

break;

case ATK_TILE:

enabled = is_action_enabled_unit_on_tile(paction->id, punit,

&& unit_perform_action(pplayer, punit->id, pcity->id, 0, "",

paction->id, ACT_REQ_SS_AGENT)) {

number_of_upgraded_units++;

break;

}

}

const struct unit *target_unit)

{

struct ane_expl *explnat;

/* Explain why the action was illegal. */

explnat = expl_act_not_enabl(actor, stopped_action,

if (!utype_can_do_act_when_ustate(unit_type_get(actor),

stopped_action, USP_LIVABLE_TILE,

FALSE)

unit_type_iterate(utype) {

if (utype_can_do_act_when_ustate(utype, stopped_action,

USP_LIVABLE_TILE, FALSE)) {

case ATK_UNITS:

case ATK_TILE:

case ATK_EXTRAS:

if (target_tile == NULL) {

log_verbose("unit_perform_action() invalid target tile %d",

target_id);

#define ACTION_PERFORM_UNIT_UNITS(action, actor, target, action_performer)\

if (target_tile \

actor_unit, target_tile)) { \

bool success; \

script_server_signal_emit("action_started_unit_units", \

struct player *old_owner = unit_owner(punit);

struct player *new_owner = (new_pcity == NULL ? old_owner

: city_owner(new_pcity));

/* Calling this function when new_pcity is same as old_pcity should

* be safe with current implementation, but it is not meant to

}

}

/* This is mainly for cases where unit owner changes to one not knowing

* Railroad tech when unit is already building railroad.

* Does also send_unit_info() */

struct player *pplayer = unit_owner(punit);

struct city *pcity = tile_city(ptile);

const struct unit_type *act_utype;

/* Sanity check: The actor still exists. */

fc_assert_ret_val(pplayer, FALSE);

enum direction8 facing;

int att_hp, def_hp;

punit->tile, pdefender->tile, &facing);

if (adj) {

moves_used = unit_move_rate(punit) - punit->moves_left;

def_moves_used = unit_move_rate(pdefender) - pdefender->moves_left;

punit->tile, pdefender->tile, &facing);

fc_assert(adj);

* An attempted move to a tile a unit can't move to is always interpreted

* as trying to perform an action (unless move_do_not_act is TRUE) */

if (!move_do_not_act) {

punit, pdesttile,

FALSE, FALSE, FALSE);

bool one_action_may_be_legal

return unit_perform_action(pplayer, punit->id, tile_index(pdesttile),

NO_TARGET, "", ACTION_UNIT_MOVE3,

ACT_REQ_PLAYER);

&& ((ptrans = transporter_for_unit_at(punit, pdesttile)))

&& is_action_enabled_unit_on_unit(nmap, ACTION_TRANSPORT_EMBARK,

punit, ptrans)) {

* perform against the target tile. Action decision state can be set by

* the server it self too. */

/* Asked to be reminded to ask what actions the unit can do to a non

* existing target tile. */

log_verbose("unit_sscs_set() invalid target tile %d for unit %d",

}

punit->action_decision_want = ACT_DEC_ACTIVE;

/* Let the client know that this unit needs the player to decide

* what to do. */