Project

General

Profile

Download (23.9 KB)

Feature #1939 ยป 0043-Pass-enum-req_problem_type-to-can_city_build_improve.patch

Marko Lindqvist, 02/08/2026 10:06 AM

View differences:

ai/default/daicity.c
return 0; /* Nothing to calculate here. */
}
if (!can_city_build_improvement_now(pcity, pimprove)
if (!can_city_build_improvement_now(pcity, pimprove, RPT_CERTAIN)
|| (is_small_wonder(pimprove)
&& city_from_small_wonder(pplayer, pimprove) != nullptr)) {
return 0;
......
if (VUT_IMPROVEMENT == preq->source.kind && preq->present) {
building = preq->source.value.building;
if (!can_city_build_improvement_now(pcity, building)
if (!can_city_build_improvement_now(pcity, building, RPT_CERTAIN)
|| !is_improvement(building)) {
building = nullptr;
break;
......
/* TODO: Ruleset cache for buildings with specific flag */
improvement_iterate(impr) {
if (improvement_has_flag(impr, preq->source.value.impr_flag)) {
if (can_city_build_improvement_now(pcity, impr)
if (can_city_build_improvement_now(pcity, impr, RPT_CERTAIN)
&& is_improvement(impr)) {
if (building == nullptr) {
building = impr;
ai/default/daimilitary.c
pcity)))) {
CITY_LOG(LOG_DEBUG, pcity, "cannot build unit %s",
utype_rule_name(punittype));
} else if (can_city_build_improvement_now(pcity, impr_req)) {
} else if (can_city_build_improvement_now(pcity, impr_req,
RPT_CERTAIN)) {
/* Building this unit requires a specific type of improvement.
* So we build this improvement instead. This may not be the
* best behavior. */
......
if (wall_id != B_LAST
&& pcity->server.adv->building_want[wall_id] != 0 && our_def != 0
&& can_city_build_improvement_now(pcity, pimprove)
&& can_city_build_improvement_now(pcity, pimprove, RPT_CERTAIN)
&& (danger < 101 || num_defenders > 1
|| (city_data->grave_danger == 0
&& pplayer->economic.gold
ai/default/daitech.c
building = utype_needs_improvement(deftype, pcity);
if (building != NULL
&& !can_player_build_improvement_direct(pplayer, building)) {
&& !can_player_build_improvement_direct(pplayer, building,
RPT_CERTAIN)) {
const struct req_context context = {
.player = pplayer,
.city = pcity,
......
building = utype_needs_improvement(iunit, pcity);
if (building != NULL
&& !can_player_build_improvement_direct(pplayer, building)) {
&& !can_player_build_improvement_direct(pplayer, building,
RPT_CERTAIN)) {
requirement_vector_iterate(&building->reqs, preq) {
if (VUT_ADVANCE == preq->source.kind && preq->present) {
int iimprtech = advance_number(preq->source.value.advance);
ai/default/daitools.c
int id = improvement_index(pimprove);
if (pcity->server.adv->building_want[id] > want
&& can_city_build_improvement_now(pcity, pimprove)) {
&& can_city_build_improvement_now(pcity, pimprove, RPT_CERTAIN)) {
want = pcity->server.adv->building_want[id];
chosen = pimprove;
}
client/climisc.c
}
improvement_iterate(pimprove) {
if (can_player_build_improvement_now(client.conn.playing, pimprove)) {
if (can_player_build_improvement_now(client.conn.playing, pimprove,
RPT_CERTAIN)) {
targets[cids_used].kind = VUT_IMPROVEMENT;
targets[cids_used].value.building = pimprove;
cids_used++;
......
if (NULL != pcity) {
/* Can the city build? */
can_build = can_city_build_improvement_now(pcity, pimprove);
can_build = can_city_build_improvement_now(pcity, pimprove,
RPT_CERTAIN);
can_eventually_build = can_city_build_improvement_later(pcity,
pimprove);
} else if (NULL != pplayer) {
/* Can our player build? */
can_build = can_player_build_improvement_now(pplayer, pimprove);
can_build = can_player_build_improvement_now(pplayer, pimprove,
RPT_CERTAIN);
can_eventually_build = can_player_build_improvement_later(pplayer,
pimprove);
} else {
/* Global observer case: can any player build? */
can_build = FALSE;
players_iterate(aplayer) {
if (can_player_build_improvement_now(aplayer, pimprove)) {
if (can_player_build_improvement_now(aplayer, pimprove,
RPT_CERTAIN)) {
can_build = TRUE;
break;
}
client/gui-sdl2/wldlg.c
pstr->bgcol = (SDL_Color) {0, 0, 0, 0};
improvement_iterate(pimprove) {
can_build = can_player_build_improvement_now(client.conn.playing, pimprove);
can_build = can_player_build_improvement_now(client.conn.playing, pimprove,
RPT_CERTAIN);
can_eventually_build =
can_player_build_improvement_later(client.conn.playing, pimprove);
/* If there's a city, can the city build the improvement? */
if (pcity) {
can_build = can_build && can_city_build_improvement_now(pcity, pimprove);
can_build = can_build && can_city_build_improvement_now(pcity, pimprove,
RPT_CERTAIN);
can_eventually_build = can_eventually_build
&& can_city_build_improvement_later(pcity, pimprove);
}
client/gui-sdl3/wldlg.c
pstr->bgcol = (SDL_Color) {0, 0, 0, 0};
improvement_iterate(pimprove) {
can_build = can_player_build_improvement_now(client.conn.playing, pimprove);
can_build = can_player_build_improvement_now(client.conn.playing, pimprove,
RPT_CERTAIN);
can_eventually_build =
can_player_build_improvement_later(client.conn.playing, pimprove);
/* If there's a city, can the city build the improvement? */
if (pcity) {
can_build = can_build && can_city_build_improvement_now(pcity, pimprove);
can_build = can_build && can_city_build_improvement_now(pcity, pimprove,
RPT_CERTAIN);
can_eventually_build = can_eventually_build
&& can_city_build_improvement_later(pcity, pimprove);
}
common/city.c
it is obsolete.
**************************************************************************/
bool can_city_build_improvement_direct(const struct city *pcity,
const struct impr_type *pimprove)
const struct impr_type *pimprove,
const enum req_problem_type prob_type)
{
if (!can_player_build_improvement_direct(city_owner(pcity), pimprove)) {
if (!can_player_build_improvement_direct(city_owner(pcity), pimprove,
prob_type)) {
return FALSE;
}
......
the building is obsolete.
**************************************************************************/
bool can_city_build_improvement_now(const struct city *pcity,
const struct impr_type *pimprove)
const struct impr_type *pimprove,
const enum req_problem_type prob_type)
{
if (!can_city_build_improvement_direct(pcity, pimprove)) {
if (!can_city_build_improvement_direct(pcity, pimprove,
prob_type)) {
return FALSE;
}
if (improvement_obsolete(city_owner(pcity), pimprove, pcity)) {
......
case VUT_UTYPE:
return can_city_build_unit_direct(nmap, pcity, target->value.utype);
case VUT_IMPROVEMENT:
return can_city_build_improvement_direct(pcity, target->value.building);
return can_city_build_improvement_direct(pcity, target->value.building,
RPT_CERTAIN);
default:
break;
};
......
case VUT_UTYPE:
return can_city_build_unit_now(nmap, pcity, target->value.utype);
case VUT_IMPROVEMENT:
return can_city_build_improvement_now(pcity, target->value.building);
return can_city_build_improvement_now(pcity, target->value.building,
RPT_CERTAIN);
default:
break;
};
......
/* Just pick the first available item. */
improvement_iterate(pimprove) {
if (can_city_build_improvement_direct(pcity, pimprove)) {
if (can_city_build_improvement_direct(pcity, pimprove,
RPT_CERTAIN)) {
found = TRUE;
pcity->production.kind = VUT_IMPROVEMENT;
pcity->production.value.building = pimprove;
common/city.h
const struct impr_type *pimprove);
bool can_city_build_improvement_direct(const struct city *pcity,
const struct impr_type *pimprove);
const struct impr_type *pimprove,
const enum req_problem_type prob_type);
bool can_city_build_improvement_later(const struct city *pcity,
const struct impr_type *pimprove);
bool can_city_build_improvement_now(const struct city *pcity,
const struct impr_type *pimprove);
const struct impr_type *pimprove,
const enum req_problem_type prob_type);
bool can_city_build_unit_direct(const struct civ_map *nmap,
const struct city *pcity,
common/improvement.c
}
/**********************************************************************//**
Whether player can build given building somewhere, ignoring whether it
is obsolete.
Whether player can build given building somewhere, ignoring whether it
is obsolete.
**************************************************************************/
bool can_player_build_improvement_direct(const struct player *p,
const struct impr_type *pimprove)
const struct impr_type *pimprove,
const enum req_problem_type prob_type)
{
const struct req_context context = { .player = p };
......
requirement_vector_iterate(&pimprove->reqs, preq) {
if (preq->range >= REQ_RANGE_PLAYER
&& !is_req_active(&context, nullptr, preq, RPT_CERTAIN)) {
&& !is_req_active(&context, nullptr, preq, prob_type)) {
return FALSE;
}
} requirement_vector_iterate_end;
/* Check for space part construction. This assumes that space parts have
/* Check for space part construction. This assumes that space parts have
* no other effects. */
if (building_has_effect(pimprove, EFT_SS_STRUCTURAL)) {
space_part = TRUE;
......
Returns FALSE if building is obsolete.
**************************************************************************/
bool can_player_build_improvement_now(const struct player *p,
struct impr_type *pimprove)
struct impr_type *pimprove,
const enum req_problem_type prob_type)
{
if (!can_player_build_improvement_direct(p, pimprove)) {
if (!can_player_build_improvement_direct(p, pimprove, prob_type)) {
return FALSE;
}
if (improvement_obsolete(p, pimprove, nullptr)) {
common/improvement.h
const struct impr_type *pimprove);
bool can_player_build_improvement_direct(const struct player *p,
const struct impr_type *pimprove);
const struct impr_type *pimprove,
const enum req_problem_type prob_type);
bool can_player_build_improvement_later(const struct player *p,
const struct impr_type *pimprove);
bool can_player_build_improvement_now(const struct player *p,
struct impr_type *pimprove);
struct impr_type *pimprove,
const enum req_problem_type prob_type);
/* Initialization and iteration */
void improvements_init(void);
common/scriptcore/api_game_methods.c
LUASCRIPT_CHECK_SELF(L, pplayer, FALSE);
LUASCRIPT_CHECK_ARG_NIL(L, itype, 3, Building_Type, FALSE);
return can_player_build_improvement_direct(pplayer, itype);
return can_player_build_improvement_direct(pplayer, itype, RPT_CERTAIN);
}
/**********************************************************************//**
common/unittype.c
} else if (is_small_wonder(preq->source.value.building)) {
if (!city_from_wonder(p, preq->source.value.building)
&& consider_reg_impr_req
&& !can_player_build_improvement_direct(p, preq->source.value.building)) {
&& !can_player_build_improvement_direct(p, preq->source.value.building,
RPT_CERTAIN)) {
return FALSE;
}
} else {
if (consider_reg_impr_req
&& !can_player_build_improvement_direct(p, preq->source.value.building)) {
&& !can_player_build_improvement_direct(p, preq->source.value.building,
RPT_CERTAIN)) {
return FALSE;
}
}
server/advisors/advbuilding.c
|| VUT_UTYPE == wonder_city->production.kind /* changed to defender? */
|| !is_wonder(wonder_city->production.value.building)
|| !can_city_build_improvement_now(wonder_city,
wonder_city->production.value.building)
wonder_city->production.value.building,
RPT_CERTAIN)
|| !is_improvement_productive(wonder_city,
wonder_city->production.value.building)) {
/* Find a new wonder city! */
......
id = improvement_index(pimprove);
if (pcity->server.adv->building_want[id] > want
&& can_city_build_improvement_now(pcity, pimprove)) {
&& can_city_build_improvement_now(pcity, pimprove,
RPT_CERTAIN)) {
want = pcity->server.adv->building_want[id];
chosen = pimprove;
}
......
/* Build the first thing we can think of (except moving small wonder). */
improvement_iterate(pimprove) {
if (can_city_build_improvement_now(pcity, pimprove)
if (can_city_build_improvement_now(pcity, pimprove, RPT_CERTAIN)
&& pimprove->genus != IG_SMALL_WONDER) {
struct universal target = {
.kind = VUT_IMPROVEMENT,
server/cityturn.c
if (VUT_IMPROVEMENT == pcity->production.kind
&& is_great_wonder(pimprove)
&& (1 >= city_production_turns_to_build(pcity, TRUE)
&& can_city_build_improvement_now(pcity, pimprove))) {
&& can_city_build_improvement_now(pcity, pimprove,
RPT_CERTAIN))) {
notify_conn(dest, city_tile(pcity),
E_WONDER_WILL_BE_BUILT, ftc_server,
_("Notice: Wonder %s in %s will be finished next turn."),
......
}
break;
case VUT_IMPROVEMENT:
if (can_city_build_improvement_now(pcity, pcity->production.value.building)) {
if (can_city_build_improvement_now(pcity, pcity->production.value.building,
RPT_CERTAIN)) {
/* We can build space and coinage again, and possibly others. */
log_base(LOG_BUILD_TARGET, "%s repeats building %s", city_name_get(pcity),
improvement_rule_name(pcity->production.value.building));
......
const struct impr_type *check = pimprove;
const struct impr_type *best_upgrade = nullptr;
if (!can_city_build_improvement_direct(pcity, check)) {
if (!can_city_build_improvement_direct(pcity, check, RPT_CERTAIN)) {
return nullptr;
}
while (valid_improvement(check = improvement_replacement(check))) {
if (can_city_build_improvement_direct(pcity, check)) {
if (can_city_build_improvement_direct(pcity, check, RPT_CERTAIN)) {
best_upgrade = check;
}
}
......
const struct impr_type *producing = pcity->production.value.building;
const struct impr_type *upgrading = building_upgrades_to(pcity, producing);
if (upgrading && can_city_build_improvement_now(pcity, upgrading)) {
if (upgrading
&& can_city_build_improvement_now(pcity, upgrading, RPT_CERTAIN)) {
notify_player(city_owner(pcity), city_tile(pcity),
E_UNIT_UPGRADED, ftc_server,
_("Production of %s is upgraded to %s in %s."),
......
/* The final (after upgrade) build target */
pimprove = pcity->production.value.building;
if (!can_city_build_improvement_now(pcity, pimprove)) {
if (!can_city_build_improvement_now(pcity, pimprove, RPT_CERTAIN)) {
notify_player(pplayer, city_tile(pcity), E_CITY_CANTBUILD, ftc_server,
_("%s is building %s, which is no longer available."),
city_link(pcity),
server/techtools.c
if (pcity->production.kind == VUT_IMPROVEMENT
&& !can_city_build_improvement_now(pcity,
pcity->production.value.building)) {
pcity->production.value.building,
RPT_CERTAIN)) {
notify_player(pplayer, city_tile(pcity),
E_CITY_CANTBUILD, ftc_server,
_("%s can't build %s. The required technology was "
    (1-1/1)