HostedRedmine.com has moved to the Planio platform. All logins and passwords remained the same. All users will be able to login and use Redmine just as before. *Read more...*
Feature #875938 ยป 0013-Move-target-finders-to-the-actions-module.patch
| common/actions.c | ||
|---|---|---|
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
city.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_city(struct unit *actor, struct city *target,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_CITY)) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_city(actor, act, target))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* city. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find a city to target for an action on the specified tile.
|
||
|
Returns NULL if no proper target is found.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct city *action_tgt_city(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
struct city *target = tile_city(target_tile);
|
||
|
if (target && may_unit_act_vs_city(actor, target, accept_all_actions)) {
|
||
|
/* It may be possible to act against this city. */
|
||
|
return target;
|
||
|
}
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
unit.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_unit(struct unit *actor, struct unit *target,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_UNIT)) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_unit(actor, act, target))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* unit. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find a unit to target for an action at the specified tile.
|
||
|
Returns the first unit found at the tile that the actor may act against
|
||
|
or NULL if no proper target is found.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct unit *action_tgt_unit(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
unit_list_iterate(target_tile->units, target) {
|
||
|
if (may_unit_act_vs_unit(actor, target, accept_all_actions)) {
|
||
|
return target;
|
||
|
}
|
||
|
} unit_list_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns the tile iff it, from the point of view of the owner of the
|
||
|
actor unit, looks like a target tile.
|
||
|
Returns NULL if the player knows that the actor unit can't do any
|
||
|
action (that specifies its target as a tile) to the tile.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act the tile will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct tile *action_tgt_tile(struct unit *actor,
|
||
|
struct tile *target,
|
||
|
const struct extra_type *target_extra,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return NULL;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
struct act_prob prob;
|
||
|
if (action_id_get_actor_kind(act) != AAK_UNIT) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
switch (action_id_get_target_kind(act)) {
|
||
|
case ATK_TILE:
|
||
|
prob = action_prob_vs_tile(actor, act, target, target_extra);
|
||
|
break;
|
||
|
case ATK_UNITS:
|
||
|
prob = action_prob_vs_units(actor, act, target);
|
||
|
break;
|
||
|
case ATK_CITY:
|
||
|
case ATK_UNIT:
|
||
|
case ATK_SELF:
|
||
|
/* Target not specified by tile. */
|
||
|
continue;
|
||
|
case ATK_COUNT:
|
||
|
/* Invalid target kind */
|
||
|
fc_assert(action_id_get_target_kind(act) != ATK_COUNT);
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(prob)) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* tile. */
|
||
|
return target;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
extra located at the target tile.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_tile_extra(const struct unit *actor,
|
||
|
const struct tile *tgt_tile,
|
||
|
const struct extra_type *tgt_extra,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || tgt_tile == NULL || tgt_extra == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_TILE
|
||
|
&& action_id_has_complex_target(act))) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_tile(actor, act,
|
||
|
tgt_tile, tgt_extra))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* extra. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find an extra to target for an action at the specified tile.
|
||
|
Returns the first extra found that the actor may act against at the tile
|
||
|
or NULL if no proper target is found. (Note that some actions requires
|
||
|
the absence of an extra since they result in its creation while other
|
||
|
requires its presence.)
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct extra_type *action_tgt_tile_extra(const struct unit *actor,
|
||
|
const struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
extra_type_re_active_iterate(target) {
|
||
|
if (may_unit_act_vs_tile_extra(actor, target_tile, target,
|
||
|
accept_all_actions)) {
|
||
|
return target;
|
||
|
}
|
||
|
} extra_type_re_active_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Return ui_name ruleset variable name for the action.
|
||
| common/actions.h | ||
|---|---|---|
|
action_actor_utype_hard_reqs_ok(enum action_result result,
|
||
|
const struct unit_type *actor_unittype);
|
||
|
/* Action target on tile locators */
|
||
|
struct city *action_tgt_city(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
struct unit *action_tgt_unit(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
struct tile *action_tgt_tile(struct unit *actor,
|
||
|
struct tile *target_tile,
|
||
|
const struct extra_type *target_extra,
|
||
|
bool accept_all_actions);
|
||
|
struct extra_type *action_tgt_tile_extra(const struct unit *actor,
|
||
|
const struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
/* Reasoning about actions */
|
||
|
bool action_immune_government(struct government *gov, action_id act);
|
||
| server/actiontools.c | ||
|---|---|---|
|
EFT_CASUS_BELLI_COMPLETE);
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
city.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_city(struct unit *actor, struct city *target,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_CITY)) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_city(actor, act, target))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* city. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find a city to target for an action on the specified tile.
|
||
|
Returns NULL if no proper target is found.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct city *action_tgt_city(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
struct city *target = tile_city(target_tile);
|
||
|
if (target && may_unit_act_vs_city(actor, target, accept_all_actions)) {
|
||
|
/* It may be possible to act against this city. */
|
||
|
return target;
|
||
|
}
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
unit.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_unit(struct unit *actor, struct unit *target,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_UNIT)) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_unit(actor, act, target))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* unit. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find a unit to target for an action at the specified tile.
|
||
|
Returns the first unit found at the tile that the actor may act against
|
||
|
or NULL if no proper target is found.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct unit *action_tgt_unit(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
unit_list_iterate(target_tile->units, target) {
|
||
|
if (may_unit_act_vs_unit(actor, target, accept_all_actions)) {
|
||
|
return target;
|
||
|
}
|
||
|
} unit_list_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns the tile iff it, from the point of view of the owner of the
|
||
|
actor unit, looks like a target tile.
|
||
|
Returns NULL if the player knows that the actor unit can't do any
|
||
|
action (that specifies its target as a tile) to the tile.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act the tile will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct tile *action_tgt_tile(struct unit *actor,
|
||
|
struct tile *target,
|
||
|
const struct extra_type *target_extra,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || target == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return NULL;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
struct act_prob prob;
|
||
|
if (action_id_get_actor_kind(act) != AAK_UNIT) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
switch (action_id_get_target_kind(act)) {
|
||
|
case ATK_TILE:
|
||
|
prob = action_prob_vs_tile(actor, act, target, target_extra);
|
||
|
break;
|
||
|
case ATK_UNITS:
|
||
|
prob = action_prob_vs_units(actor, act, target);
|
||
|
break;
|
||
|
case ATK_CITY:
|
||
|
case ATK_UNIT:
|
||
|
case ATK_SELF:
|
||
|
/* Target not specified by tile. */
|
||
|
continue;
|
||
|
case ATK_COUNT:
|
||
|
/* Invalid target kind */
|
||
|
fc_assert(action_id_get_target_kind(act) != ATK_COUNT);
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(prob)) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* tile. */
|
||
|
return target;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns TRUE iff, from the point of view of the owner of the actor unit,
|
||
|
it looks like the actor unit may be able to do any action to the target
|
||
|
extra located at the target tile.
|
||
|
If the owner of the actor unit doesn't have the knowledge needed to know
|
||
|
for sure if the unit can act TRUE will be returned.
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
static bool may_unit_act_vs_tile_extra(const struct unit *actor,
|
||
|
const struct tile *tgt_tile,
|
||
|
const struct extra_type *tgt_extra,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
if (actor == NULL || tgt_tile == NULL || tgt_extra == NULL) {
|
||
|
/* Can't do any actions if actor or target are missing. */
|
||
|
return FALSE;
|
||
|
}
|
||
|
action_iterate(act) {
|
||
|
if (!(action_id_get_actor_kind(act) == AAK_UNIT
|
||
|
&& action_id_get_target_kind(act) == ATK_TILE
|
||
|
&& action_id_has_complex_target(act))) {
|
||
|
/* Not a relevant action. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_id_is_rare_pop_up(act) && !accept_all_actions) {
|
||
|
/* Not relevant since not accepted here. */
|
||
|
continue;
|
||
|
}
|
||
|
if (action_prob_possible(action_prob_vs_tile(actor, act,
|
||
|
tgt_tile, tgt_extra))) {
|
||
|
/* The actor unit may be able to do this action to the target
|
||
|
* extra. */
|
||
|
return TRUE;
|
||
|
}
|
||
|
} action_iterate_end;
|
||
|
return FALSE;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Find an extra to target for an action at the specified tile.
|
||
|
Returns the first extra found that the actor may act against at the tile
|
||
|
or NULL if no proper target is found. (Note that some actions requires
|
||
|
the absence of an extra since they result in its creation while other
|
||
|
requires its presence.)
|
||
|
If the only action(s) that can be performed against a target has the
|
||
|
rare_pop_up property the target will only be considered valid if the
|
||
|
accept_all_actions argument is TRUE.
|
||
|
**************************************************************************/
|
||
|
struct extra_type *action_tgt_tile_extra(const struct unit *actor,
|
||
|
const struct tile *target_tile,
|
||
|
bool accept_all_actions)
|
||
|
{
|
||
|
extra_type_re_active_iterate(target) {
|
||
|
if (may_unit_act_vs_tile_extra(actor, target_tile, target,
|
||
|
accept_all_actions)) {
|
||
|
return target;
|
||
|
}
|
||
|
} extra_type_re_active_iterate_end;
|
||
|
return NULL;
|
||
|
}
|
||
|
/**********************************************************************//**
|
||
|
Returns the action auto performer that the specified cause can force the
|
||
|
specified actor to perform. Returns NULL if no such action auto performer
|
||
| server/actiontools.h | ||
|---|---|---|
|
void action_success_actor_price(struct action *paction,
|
||
|
int actor_id, struct unit *actor);
|
||
|
struct city *action_tgt_city(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
struct unit *action_tgt_unit(struct unit *actor, struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
struct tile *action_tgt_tile(struct unit *actor,
|
||
|
struct tile *target_tile,
|
||
|
const struct extra_type *target_extra,
|
||
|
bool accept_all_actions);
|
||
|
struct extra_type *action_tgt_tile_extra(const struct unit *actor,
|
||
|
const struct tile *target_tile,
|
||
|
bool accept_all_actions);
|
||
|
const struct action_auto_perf *
|
||
|
action_auto_perf_unit_sel(const enum action_auto_perf_cause cause,
|
||
|
const struct unit *actor,
|
||
.