Freeciv-3.2
Loading...
Searching...
No Matches
daicity.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18#include <string.h>
19#include <math.h> /* pow */
20
21/* utility */
22#include "rand.h"
23#include "registry.h"
24
25/* common */
26#include "actions.h"
27#include "game.h"
28#include "government.h"
29#include "research.h"
30#include "specialist.h"
31
32/* server */
33#include "cityhand.h"
34#include "citytools.h"
35#include "cityturn.h"
36#include "notify.h"
37#include "plrhand.h"
38#include "srv_log.h"
39#include "unithand.h"
40#include "unittools.h"
41
42/* server/advisors */
43#include "advdata.h"
44#include "advtools.h"
45#include "autosettlers.h"
46#include "advbuilding.h"
47#include "infracache.h"
48
49/* ai */
50#include "aitraits.h"
51#include "difficulty.h"
52#include "handicaps.h"
53
54/* ai/default */
55#include "aihand.h"
56#include "aitools.h"
57#include "daidata.h"
58#include "daidiplomacy.h"
59#include "daidomestic.h"
60#include "daimilitary.h"
61#include "daieffects.h"
62#include "daiplayer.h"
63#include "daisettler.h"
64
65#include "daicity.h"
66
67#define LOG_BUY LOG_DEBUG
68#define LOG_EMERGENCY LOG_VERBOSE
69#define LOG_WANT LOG_VERBOSE
70
71/* TODO: AI_CITY_RECALC_SPEED should be configurable to ai difficulty.
72 -kauf */
73#define AI_CITY_RECALC_SPEED 5
74
75#define AI_BA_RECALC_SPEED 5
76
77#define SPECVEC_TAG tech
78#define SPECVEC_TYPE struct advance *
79#include "specvec.h"
80
81#define SPECVEC_TAG impr
82#define SPECVEC_TYPE const struct impr_type *
83#include "specvec.h"
84
85/* Iterate over cities within a certain range around a given city
86 * (city_here) that exist within a given city list. */
87#define city_range_iterate(city_here, list, range, city) \
88{ \
89 city_list_iterate(list, city) { \
90 if (range == REQ_RANGE_PLAYER \
91 || range == REQ_RANGE_TEAM \
92 || range == REQ_RANGE_ALLIANCE \
93 || (range == REQ_RANGE_TRADE_ROUTE \
94 && (city == city_here \
95 || have_cities_trade_route(city, city_here))) \
96 || ((range == REQ_RANGE_CITY || range == REQ_RANGE_LOCAL) \
97 && city == city_here) \
98 || (range == REQ_RANGE_CONTINENT \
99 && tile_continent(city->tile) == \
100 tile_continent(city_here->tile))) {
101
102#define city_range_iterate_end \
103 } \
104 } city_list_iterate_end; \
105}
106
107#define CITY_EMERGENCY(pcity) \
108 (pcity->surplus[O_SHIELD] < 0 || city_unhappy(pcity) \
109 || pcity->food_stock + pcity->surplus[O_FOOD] < 0)
110
111static void dai_city_sell_noncritical(struct city *pcity, bool redundant_only);
112static void resolve_city_emergency(struct ai_type *ait, struct player *pplayer,
113 struct city *pcity);
114
115/**********************************************************************/
128 struct player *pplayer,
129 const struct city *pcity,
130 const struct impr_type *pimprove,
131 const struct advance *tech,
132 adv_want building_want)
133{
134 /* The conversion factor was determined by experiment,
135 * and might need adjustment. See also dai_tech_effect_values()
136 */
137 const adv_want tech_want = building_want * def_ai_city_data(pcity, ait)->building_wait
138 * 14 / 8;
139#if 0
140 /* This logging is relatively expensive,
141 * so activate it only while necessary. */
142 TECH_LOG(LOG_DEBUG, pplayer, tech,
143 "wanted by %s for building: %d -> %d",
144 city_name_get(pcity), improvement_rule_name(pimprove),
145 building_want, tech_want);
146#endif /* 0 */
147 if (tech) {
148 def_ai_player_data(pplayer, ait)->tech_want[advance_index(tech)] += tech_want;
149 }
150}
151
152/**********************************************************************/
157 struct player *pplayer,
158 const struct city *pcity,
159 const struct impr_type *pimprove,
161 adv_want building_want)
162{
163 int t;
165
166 for (t = 0; t < n_needed_techs; t++) {
167 want_tech_for_improvement_effect(ait, pplayer, pcity, pimprove,
169 building_want);
170 }
171}
172
173/**********************************************************************/
178 struct player *pplayer,
179 const struct city *pcity,
180 const struct impr_type *pimprove,
181 adv_want building_want)
182{
184 if (pobs->source.kind == VUT_ADVANCE && pobs->present) {
185 want_tech_for_improvement_effect(ait, pplayer, pcity, pimprove,
186 pobs->source.value.advance,
187 -building_want);
188 }
190}
191
192/**********************************************************************/
200static void dai_barbarian_choose_build(struct player *pplayer,
201 struct city *pcity,
202 struct adv_choice *choice)
203{
204 struct unit_type *bestunit = NULL;
205 int i, bestattack = 0;
206
207 /* Choose the best unit among the basic ones */
208 for (i = 0; i < num_role_units(L_BARBARIAN_BUILD); i++) {
210
211 if (iunit->attack_strength > bestattack
212 && can_city_build_unit_now(pcity, iunit)) {
213 bestunit = iunit;
214 bestattack = iunit->attack_strength;
215 }
216 }
217
218 /* Choose among those made available through other civ's research */
219 for (i = 0; i < num_role_units(L_BARBARIAN_BUILD_TECH); i++) {
221
222 if (iunit->attack_strength > bestattack
223 && can_city_build_unit_now(pcity, iunit)) {
224 bestunit = iunit;
225 bestattack = iunit->attack_strength;
226 }
227 }
228
229 /* If found anything, put it into the choice */
230 if (bestunit) {
231 choice->value.utype = bestunit;
232 /* "Overriding military emergency" indicator */
234 choice->type = CT_ATTACKER;
235 adv_choice_set_use(choice, "barbarian");
236 } else {
237 log_base(LOG_WANT, "Barbarians don't know what to build!");
238 }
239}
240
241/**********************************************************************/
249static void dai_city_choose_build(struct ai_type *ait, struct player *pplayer,
250 struct city *pcity)
251{
252 struct adv_choice *newchoice;
253 struct adv_data *adv = adv_data_get(pplayer, NULL);
254 struct ai_city *city_data = def_ai_city_data(pcity, ait);
255
256 if (has_handicap(pplayer, H_AWAY)
257 && !city_built_last_turn(pcity)
258 && city_data->urgency == 0) {
259 /* Don't change existing productions unless we have to. */
260 return;
261 }
262
263 if (is_barbarian(pplayer)) {
264 dai_barbarian_choose_build(pplayer, pcity, &(city_data->choice));
265 } else {
266 if ((city_data->choice.want < DAI_WANT_MILITARY_EMERGENCY
267 || city_data->urgency == 0)
268 && !(dai_on_war_footing(ait, pplayer) && city_data->choice.want > 0
269 && pcity->id != adv->wonder_city)) {
270 newchoice = domestic_advisor_choose_build(ait, pplayer, pcity);
273 }
274 }
275
276 /* Fallbacks */
277 if (city_data->choice.want == 0) {
278 /* Fallbacks do happen with techlevel 0, which is now default. -- Per */
279 CITY_LOG(LOG_WANT, pcity, "Falling back - didn't want to build soldiers,"
280 " workers, caravans, settlers, or buildings!");
281 city_data->choice.want = 1;
283 city_data->choice.value.utype
285 city_data->choice.type = CT_CIVILIAN;
286 adv_choice_set_use(&(city_data->choice), "fallback trade route");
287 } else {
288 unsigned int our_def = assess_defense_quadratic(ait, pcity);
289
290 if (our_def == 0
291 && dai_process_defender_want(ait, pplayer, pcity, 1,
292 &(city_data->choice), 0)) {
293 adv_choice_set_use(&(city_data->choice), "fallback defender");
294 CITY_LOG(LOG_DEBUG, pcity, "Building fallback defender");
295 } else if (best_role_unit(pcity, UTYF_SETTLERS)) {
296 city_data->choice.value.utype
298 city_data->choice.type = CT_CIVILIAN;
299 adv_choice_set_use(&(city_data->choice), "fallback worker");
300 } else {
301 CITY_LOG(LOG_ERROR, pcity, "Cannot even build a fallback "
302 "(caravan/coinage/settlers). Fix the ruleset!");
303 city_data->choice.want = 0;
304 }
305 }
306 }
307
308 if (city_data->choice.want != 0) {
309 struct universal build_new;
310
312
313#ifdef ADV_CHOICE_TRACK
314 if (city_data->choice.log_if_chosen) {
315 log_normal("%s wants %s for %s with desire " ADV_WANT_PRINTF ".",
316 city_name_get(pcity),
318 city_data->choice.use,
319 city_data->choice.want);
320 }
321#endif /* ADV_CHOICE_TRACK */
322
323 CITY_LOG(LOG_DEBUG, pcity, "wants %s with desire " ADV_WANT_PRINTF ".",
325 city_data->choice.want);
326
327 switch (city_data->choice.type) {
328 case CT_CIVILIAN:
329 case CT_ATTACKER:
330 case CT_DEFENDER:
331 build_new.kind = VUT_UTYPE;
332 build_new.value.utype = city_data->choice.value.utype;
333 break;
334 case CT_BUILDING:
336 build_new.value.building = city_data->choice.value.building;
337 break;
338 case CT_NONE:
339 build_new.kind = VUT_NONE;
340 break;
341 case CT_LAST:
343 break;
344 };
345
347 }
348}
349
350/**********************************************************************/
353static void try_to_sell_stuff(struct player *pplayer, struct city *pcity)
354{
355 improvement_iterate(pimprove) {
356 if (can_city_sell_building(pcity, pimprove)
357 && !building_has_effect(pimprove, EFT_DEFEND_BONUS)) {
358 /* selling walls to buy defenders is counterproductive -- Syela */
359 really_handle_city_sell(pplayer, pcity, pimprove);
360 break;
361 }
363}
364
365/**********************************************************************/
369static void increase_maxbuycost(struct player *pplayer, int new_value)
370{
372}
373
374/**********************************************************************/
379static void dai_upgrade_units(struct city *pcity, int limit, bool military)
380{
382 struct player *pplayer = city_owner(pcity);
383 int expenses;
384
385 {
386 /* Find upgrade unit actions */
387 int i = 0;
390 }
391
392 dai_calc_data(pplayer, NULL, &expenses, NULL);
393
395 if (pcity->owner == punit->owner) {
396 /* Only upgrade units you own, not allied ones */
397
398 const struct unit_type *old_type = unit_type_get(punit);
399 const struct unit_type *punittype = can_upgrade_unittype(pplayer, old_type);
400
401 if (military && !IS_ATTACKER(old_type)) {
402 /* Only upgrade military units this round */
403 continue;
404 } else if (!military && IS_ATTACKER(old_type)) {
405 /* Only civilians or transports this round */
406 continue;
407 }
408
409 if (punittype == NULL) {
410 continue;
411 }
412
414 if (action_ever_possible(act_id)) {
415 const struct action *paction = action_by_number(act_id);
416 int cost = unit_upgrade_price(pplayer, old_type, punittype);
417 int real_limit = limit;
418
419 /* Sinking Triremes are DANGEROUS!! We'll do anything to upgrade 'em. */
420 /* FIXME: This assumes rules to be quite close to civ/2.
421 * Of the supplied rulesets those are the only ones with
422 * UTYF_COAST unit, but... */
425 }
426 if (pplayer->economic.gold - cost > real_limit) {
427 CITY_LOG(LOG_BUY, pcity, "Upgraded %s to %s for %d (%s)",
430 cost,
431 military ? "military" : "civilian");
433 pcity->id, 0, "",
434 paction->id);
435 } else {
436 increase_maxbuycost(pplayer, cost);
437 }
438 }
440 }
442}
443
444/**********************************************************************/
450static void unit_do_disband_trad(struct player *owner, struct unit *punit,
451 const enum action_requester requester)
452{
453 const int punit_id_stored = punit->id;
454 const struct civ_map *nmap = &(wld.map);
455
457
458 /* Help Wonder gives 100% of the shields used to produce the unit to the
459 * city where it is located. */
461 struct city *tgt_city;
462
463 /* Only a city at the same tile as the unit can benefit. */
465
466 if (tgt_city
468 punit, tgt_city)) {
471 /* No shields wasted. The unit did Help Wonder. */
472 return;
473 }
474
476 /* The unit is gone. Maybe it was killed in Lua? */
477 return;
478 }
479 }
480 }
481
482 /* Disbanding a unit inside a city gives it 50% of the shields used to
483 * produce the unit. */
485 struct city *tgt_city;
486
487 /* Only a city at the same tile as the unit can benefit. */
489
490 if (tgt_city
492 punit, tgt_city)) {
495 /* The unit did Disband Unit Recover. 50% of the shields wasted. */
496 return;
497 }
498
500 /* The unit is gone. Maybe it was killed in Lua? */
501 return;
502 }
503 }
504 }
505
506 /* Try to disband even if all shields will be wasted. */
511 /* All shields wasted. The unit did Disband Unit. */
512 return;
513 }
514 }
515 }
516}
517
518/**********************************************************************/
521static void dai_spend_gold(struct ai_type *ait, struct player *pplayer)
522{
523 struct adv_choice bestchoice;
524 int cached_limit = dai_gold_reserve(pplayer);
525 int expenses;
526 bool war_footing = dai_on_war_footing(ait, pplayer);
527
528 /* Disband explorers that are at home but don't serve a purpose.
529 * FIXME: This is a hack, and should be removed once we
530 * learn how to ferry explorers to new land. */
531 city_list_iterate(pplayer->cities, pcity) {
532 struct tile *ptile = pcity->tile;
535 && pcity->id == punit->homecity
536 && def_ai_city_data(pcity, ait)->urgency == 0) {
537 CITY_LOG(LOG_BUY, pcity, "disbanding %s to increase production",
540 }
543
544 dai_calc_data(pplayer, NULL, &expenses, NULL);
545
546 do {
547 bool expensive; /* don't buy when it costs x2 unless we must */
548 int buycost;
549 int limit = cached_limit; /* cached_limit is our gold reserve */
550 struct city *pcity = NULL;
551 struct ai_city *city_data;
552
553 /* Find highest wanted item on the buy list */
555 city_list_iterate(pplayer->cities, acity) {
557
558 if (acity_data->choice.want
559 > bestchoice.want && ai_fuzzy(pplayer, TRUE)) {
561 pcity = acity;
562 }
564
565 /* We found nothing, so we're done */
566 if (pcity == NULL) {
567 break;
568 }
569
570 city_data = def_ai_city_data(pcity, ait);
571
572 /* Not dealing with this city a second time */
573 city_data->choice.want = -1;
574
576
577 /* Try upgrade units at danger location (high want is usually danger) */
578 if (city_data->urgency > 1) {
579 if (bestchoice.type == CT_BUILDING
580 && is_wonder(bestchoice.value.building)) {
581 CITY_LOG(LOG_BUY, pcity, "Wonder being built in dangerous position!");
582 } else {
583 /* If we have urgent want, spend more */
584 int upgrade_limit = limit;
585
586 if (city_data->urgency > 1) {
588 }
589 /* Upgrade only military units now */
591 }
592 }
593
594 if (pcity->anarchy != 0 && bestchoice.type != CT_BUILDING) {
595 continue; /* Nothing we can do */
596 }
597
598 /* Cost to complete production */
600
601 if (buycost <= 0) {
602 continue; /* Already completed */
603 }
604
606 && utype_is_cityfounder(bestchoice.value.utype)) {
607 if (get_city_bonus(pcity, EFT_SHRINK_FOOD) <= 0
608 && bestchoice.value.utype->pop_cost > 0
609 && city_size_get(pcity) <= bestchoice.value.utype->pop_cost) {
610 /* Don't buy settlers in cities that cannot afford the population cost. */
611 /* This used to check also if city is about to grow to required size
612 * next turn and allow buying of settlers in that case, but current
613 * order of end/start turn activities is such that settler building
614 * fails already before city grows. */
615 continue;
616 } else if (city_list_size(pplayer->cities) > 6) {
617 /* Don't waste precious money buying settlers late game
618 * since this raises taxes, and we want science. Adjust this
619 * again when our tax algorithm is smarter. */
620 continue;
621 } else if (war_footing) {
622 continue;
623 }
624 } else {
625 /* We are not a settler. Therefore we increase the cash need we
626 * balance our buy desire with to keep cash at hand for emergencies
627 * and for upgrades */
628 limit *= 2;
629 }
630
631 /* It costs x2 to buy something with no shields contributed */
632 expensive = (pcity->shield_stock == 0)
633 || (pplayer->economic.gold - buycost < limit);
634
635 if (bestchoice.type == CT_ATTACKER
636 && buycost
637 > utype_build_shield_cost(pcity, NULL, bestchoice.value.utype) * 2
638 && !war_footing) {
639 /* Too expensive for an offensive unit */
640 continue;
641 }
642
643 /* FIXME: Here Syela wanted some code to check if
644 * pcity was doomed, and we should therefore attempt
645 * to sell everything in it of non-military value */
646
647 if (pplayer->economic.gold - expenses >= buycost
648 && (!expensive
649 || (city_data->grave_danger != 0
650 && assess_defense(ait, pcity) == 0)
651 || (bestchoice.want > 200 && city_data->urgency > 1))) {
652 /* Buy stuff */
653 CITY_LOG(LOG_BUY, pcity, "Crash buy of %s for %d (want " ADV_WANT_PRINTF ")",
655 buycost,
656 bestchoice.want);
657 really_handle_city_buy(pplayer, pcity);
658 } else if (city_data->grave_danger != 0
659 && bestchoice.type == CT_DEFENDER
660 && assess_defense(ait, pcity) == 0) {
661 /* We have no gold but MUST have a defender */
662 CITY_LOG(LOG_BUY, pcity, "must have %s but can't afford it (%d < %d)!",
664 pplayer->economic.gold,
665 buycost);
666 try_to_sell_stuff(pplayer, pcity);
667 if (pplayer->economic.gold - expenses >= buycost) {
668 CITY_LOG(LOG_BUY, pcity, "now we can afford it (sold something)");
669 really_handle_city_buy(pplayer, pcity);
670 }
672 }
673 } while (TRUE);
674
675 if (!war_footing) {
676 /* Civilian upgrades now */
677 city_list_iterate(pplayer->cities, pcity) {
680 }
681
682 log_base(LOG_BUY, "%s wants to keep %d in reserve (tax factor %d)",
683 player_name(pplayer), cached_limit, pplayer->ai_common.maxbuycost);
684}
685
686/**********************************************************************/
689static int unit_food_upkeep(struct unit *punit)
690{
691 struct player *pplayer = unit_owner(punit);
692 int upkeep = utype_upkeep_cost(unit_type_get(punit), pplayer, O_FOOD);
693
694 if (punit->id != 0 && punit->homecity == 0)
695 upkeep = 0; /* thanks, Peter */
696
697 return upkeep;
698}
699
700/**********************************************************************/
708static int unit_foodbox_cost(struct unit *punit)
709{
710 int pop_cost = unit_type_get(punit)->pop_cost;
711
712 if (pop_cost <= 0) {
713 return 0;
714 }
715
716 if (punit->id == 0) {
717 /* It is a virtual unit, so must start in a city... */
718 struct city *pcity = tile_city(unit_tile(punit));
719 int size = city_size_get(pcity);
720 int cost = 0;
721 int i;
722
723 /* The default is to lose 100%. The granary bonus reduces this. */
724 int foodloss_pct = 100 - city_shrink_granary_savings(pcity);
725
726 foodloss_pct = CLIP(0, foodloss_pct, 100);
727 fc_assert_ret_val(pcity != NULL, -1);
728 fc_assert(size >= pop_cost);
729
730 for (i = pop_cost; i > 0 ; i--) {
732 }
733 cost = cost * foodloss_pct / 100;
734
735 return cost;
736 }
737
738 return 30;
739}
740
741/**********************************************************************/
748 struct city *pcity)
749{
750 struct unit *virtualunit;
751 int want;
753 struct extra_type *best_target;
754 struct tile *best_tile = NULL; /* May be accessed by log_*() calls. */
755 struct tile *pcenter = city_tile(pcity);
756 struct player *pplayer = city_owner(pcity);
757 struct adv_data *adv = adv_data_get(pplayer, NULL);
758 struct ai_plr *ai = dai_plr_data_get(ait, pplayer, NULL);
759 struct unit_type *utype;
761 struct ai_city *city_data = def_ai_city_data(pcity, ait);
762 struct dai_private_data *private = (struct dai_private_data *)ait->private;
763 const struct civ_map *nmap = &(wld.map);
764
765 if (!private->contemplace_workers) {
766 /* AI type uses custom method to set worker want and type. */
767 return;
768 }
769
770 city_data->worker_want = 0; /* Make sure old want does not stay if we don't want now */
771
773
774 if (utype == NULL) {
775 log_debug("No UTYF_SETTLERS role unit available");
776 return;
777 }
778
779 /* Create a localized "virtual" unit to do operations with. */
780 virtualunit = unit_virtual_create(pplayer, pcity, utype, 0);
781 /* Advisors data space not allocated as it's not needed in the
782 lifetime of the virtualunit. */
786 &best_tile,
787 NULL, NULL);
788 if (unit_type_get(virtualunit)->pop_cost >= city_size_get(pcity)) {
789 /* We don't like disbanding the city as a side effect */
791
792 return;
793 }
794 /* We consider unit_food_upkeep with only half FOOD_WEIGHTING to
795 * balance the fact that unit can improve many tiles during its
796 * lifetime, and want is calculated for just one of them.
797 * Having full FOOD_WEIGHT here would mean that tile improvement of
798 * +1 food would give just zero want for settler. Other weights
799 * are lower, so +1 shield - unit food upkeep would be negative. */
800 want = (want - unit_food_upkeep(virtualunit) * FOOD_WEIGHTING / 2) * 100
803
804 /* Massage our desire based on available statistics to prevent
805 * overflooding with worker type units if they come cheap in
806 * the ruleset */
807 if (place >= 0) {
808 want /= MAX(1, ai->stats.workers[place] / (adv->stats.cities[place] + 1));
809 want -= ai->stats.workers[place];
810 } else {
811 want /= MAX(1, ai->stats.ocean_workers[-place] / (adv->stats.ocean_cities[-place] + 1));
812 want -= ai->stats.ocean_workers[-place];
813 }
814 want = MAX(want, 0);
815
816 if (place >= 0) {
817 CITY_LOG(LOG_DEBUG, pcity, "wants %s with want %d to do %s at (%d,%d), "
818 "we have %d workers and %d cities on the continent",
819 utype_rule_name(utype),
820 want,
823 ai->stats.workers[place],
824 adv->stats.cities[place]);
825 } else {
826 CITY_LOG(LOG_DEBUG, pcity, "wants %s with want %d to do %s at (%d,%d), "
827 "we have %d workers and %d cities on the ocean",
828 utype_rule_name(utype),
829 want,
833 adv->stats.ocean_cities[-place]);
834 }
835
836 fc_assert(want >= 0);
837
838 city_data->worker_want = want;
840 place >= 0 ? TC_LAND : TC_OCEAN);
841}
842
843/**********************************************************************/
849void dai_manage_cities(struct ai_type *ait, struct player *pplayer)
850{
851 pplayer->ai_common.maxbuycost = 0;
852
854 city_list_iterate(pplayer->cities, pcity) {
855 if (CITY_EMERGENCY(pcity)
856 || city_granary_size(city_size_get(pcity)) == pcity->food_stock) {
857 /* Having a full granary isn't an emergency, but we want to rearrange */
858 auto_arrange_workers(pcity); /* this usually helps */
859 }
860 if (CITY_EMERGENCY(pcity)) {
861 /* Fix critical shortages or unhappiness */
862 resolve_city_emergency(ait, pplayer, pcity);
863 }
865 sync_cities();
867 if (pplayer->economic.tax >= 30 /* Otherwise expect it to increase tax */
868 && player_get_expected_income(pplayer) < -(pplayer->economic.gold)) {
869 int count = city_list_size(pplayer->cities);
870 struct city *sellers[count + 1];
871 int i;
872
873 /* Randomized order */
874 count = 0;
875 city_list_iterate(pplayer->cities, pcity) {
876 sellers[count++] = pcity;
878
879 for (i = 0; i < count; i++) {
880 int replace = fc_rand(count);
881 struct city *tmp;
882
883 tmp = sellers[i];
886 }
887
888 i = 0;
889 while (player_get_expected_income(pplayer) < -(pplayer->economic.gold)
890 && i < count) {
892 }
893 }
895
897 building_advisor(pplayer);
899
900 /* Initialize the infrastructure cache, which is used shortly. */
902 city_list_iterate(pplayer->cities, pcity) {
903 struct ai_city *city_data = def_ai_city_data(pcity, ait);
904 struct adv_choice *choice;
905
906 if (city_data->choice.want <= 0) {
907 /* Note that this function mungs the seamap, but we don't care */
909 choice = military_advisor_choose_build(ait, pplayer, pcity, &(wld.map), NULL);
910 adv_choice_copy(&(city_data->choice), choice);
911 adv_free_choice(choice);
913 }
914 if (dai_on_war_footing(ait, pplayer) && city_data->choice.want > 0) {
915 city_data->worker_want = 0;
916 city_data->founder_want = 0;
917 city_data->founder_turn = game.info.turn; /* Do not consider zero we set here
918 * valid value, if real want is needed.
919 * Recalculate immediately in such situation. */
920 continue; /* Go, soldiers! */
921 }
922 /* Will record its findings in pcity->worker_want */
926
928 if (city_data->founder_turn <= game.info.turn) {
929 /* Will record its findings in pcity->founder_want */
930 contemplate_new_city(ait, pcity);
931 /* Avoid recalculating all the time.. */
932 /* This means AI is not very opportunistic if there happens to open up spot for
933 * a new city. */
934 city_data->founder_turn =
936 } else if (pcity->server.debug) {
937 /* recalculate every turn */
938 contemplate_new_city(ait, pcity);
939 }
943 /* Reset auto settler state for the next run. */
944 dai_auto_settler_reset(ait, pplayer);
945
946 city_list_iterate(pplayer->cities, pcity) {
947 dai_city_choose_build(ait, pplayer, pcity);
948
949 /* Initialize for next turn */
950 def_ai_city_data(pcity, ait)->choice.want = -1;
952
953 dai_spend_gold(ait, pplayer);
954}
955
956/**********************************************************************/
963static bool building_crucial(const struct player *plr,
964 struct impr_type *pimprove,
965 const struct city *pcity)
966{
967#if 0 /* This check will become more complicated now. */
968 if (ai_wants_no_science(plr)
970 return FALSE;
971 }
972#endif
974 /* selling city walls is really, really dumb -- Syela */
975 || is_improvement_productive(pcity, pimprove)) {
976 return TRUE;
977 }
978
979 return FALSE;
980}
981
982/**********************************************************************/
985static void dai_city_sell_noncritical(struct city *pcity,
986 bool redundant_only)
987{
988 struct player *pplayer = city_owner(pcity);
989
990 city_built_iterate(pcity, pimprove) {
991 if (can_city_sell_building(pcity, pimprove)
992 && !building_crucial(pplayer, pimprove, pcity)
993 && (!redundant_only || is_improvement_redundant(pcity, pimprove))) {
994 int gain = impr_sell_gold(pimprove);
995
996 notify_player(pplayer, pcity->tile, E_IMP_SOLD, ftc_server,
997 PL_("%s is selling %s for %d.",
998 "%s is selling %s for %d.", gain),
999 city_link(pcity),
1001 gain);
1002 do_sell_building(pplayer, pcity, pimprove, "sold");
1003
1004 return; /* max 1 building each turn */
1005 }
1007}
1008
1009/**********************************************************************/
1028static void resolve_city_emergency(struct ai_type *ait, struct player *pplayer,
1029 struct city *pcity)
1030{
1031 struct tile *pcenter = city_tile(pcity);
1032 const struct civ_map *nmap = &(wld.map);
1033
1035 "Emergency in %s (%s, angry%d, unhap%d food%d, prod%d)",
1036 city_name_get(pcity),
1037 city_unhappy(pcity) ? "unhappy" : "content",
1040 pcity->surplus[O_FOOD],
1041 pcity->surplus[O_SHIELD]);
1042
1044 struct city *acity = tile_worked(atile);
1045
1046 if (acity && acity != pcity && city_owner(acity) == city_owner(pcity)) {
1047 log_base(LOG_EMERGENCY, "%s taking over %s square in (%d, %d)",
1049
1050#ifndef FREECIV_NDEBUG
1051 int ax, ay;
1052#endif
1054 continue);
1055
1056 if (is_free_worked(acity, atile)) {
1057 /* Can't remove a worker here. */
1058 continue;
1059 }
1060
1062 acity->specialists[DEFAULT_SPECIALIST]++;
1064 }
1066
1067 auto_arrange_workers(pcity);
1068
1069 if (!CITY_EMERGENCY(pcity)) {
1070 log_base(LOG_EMERGENCY, "Emergency in %s resolved", city_name_get(pcity));
1071 goto cleanup;
1072 }
1073
1075 if (city_unhappy(pcity)
1076 && (utype_happy_cost(unit_type_get(punit), pplayer) > 0
1078 && def_ai_unit_data(punit, ait)->passenger == 0) {
1079 UNIT_LOG(LOG_EMERGENCY, punit, "is causing unrest, disbanded");
1080 /* TODO: if Help Wonder stops blocking Disband Unit there may be
1081 * cases where Disband Unit should be selected. Example: Field unit
1082 * in allied city that is building a wonder that makes the ally win
1083 * without sharing the victory. */
1084 /* TODO: Should the unit try to find legal targets at adjacent tiles?
1085 * Should it consider other self eliminating actions than the
1086 * components of the traditional disband? */
1088 city_refresh(pcity);
1089 }
1091
1092 if (CITY_EMERGENCY(pcity)) {
1093 log_base(LOG_EMERGENCY, "Emergency in %s remains unresolved",
1094 city_name_get(pcity));
1095 } else {
1097 "Emergency in %s resolved by disbanding unit(s)",
1098 city_name_get(pcity));
1099 }
1100
1101 cleanup:
1103 sync_cities();
1104}
1105
1106/**********************************************************************/
1109void dai_city_alloc(struct ai_type *ait, struct city *pcity)
1110{
1111 struct ai_city *city_data = fc_calloc(1, sizeof(struct ai_city));
1112
1113 city_data->building_wait = BUILDING_WAIT_MINIMUM;
1114 adv_init_choice(&(city_data->choice));
1115
1116 city_set_ai_data(pcity, ait, city_data);
1117}
1118
1119/**********************************************************************/
1122void dai_city_free(struct ai_type *ait, struct city *pcity)
1123{
1124 struct ai_city *city_data = def_ai_city_data(pcity, ait);
1125
1126 if (city_data != NULL) {
1127 adv_deinit_choice(&(city_data->choice));
1128 city_set_ai_data(pcity, ait, NULL);
1130 }
1131}
1132
1133/**********************************************************************/
1136void dai_city_save(struct ai_type *ait, const char *aitstr,
1137 struct section_file *file, const struct city *pcity,
1138 const char *citystr)
1139{
1140 struct ai_city *city_data = def_ai_city_data(pcity, ait);
1141
1142 /* FIXME: remove this when the urgency is properly recalculated. */
1143 secfile_insert_int(file, city_data->urgency, "%s.%s.urgency", citystr, aitstr);
1144
1145 /* avoid fc_rand recalculations on subsequent reload. */
1146 secfile_insert_int(file, city_data->building_turn, "%s.%s.building_turn",
1147 citystr, aitstr);
1148 secfile_insert_int(file, city_data->building_wait, "%s.%s.building_wait",
1149 citystr, aitstr);
1150
1151 /* avoid fc_rand and expensive recalculations on subsequent reload. */
1152 secfile_insert_int(file, city_data->founder_turn, "%s.%s.founder_turn",
1153 citystr, aitstr);
1154 secfile_insert_int(file, city_data->founder_want, "%s.%s.founder_want",
1155 citystr, aitstr);
1156 secfile_insert_bool(file, city_data->founder_boat, "%s.%s.founder_boat",
1157 citystr, aitstr);
1158}
1159
1160/**********************************************************************/
1163void dai_city_load(struct ai_type *ait, const char *aitstr,
1164 const struct section_file *file,
1165 struct city *pcity, const char *citystr)
1166{
1167 struct ai_city *city_data = def_ai_city_data(pcity, ait);
1168
1169 /* FIXME: remove this when the urgency is properly recalculated. */
1170 city_data->urgency
1171 = secfile_lookup_int_default(file, 0, "%s.%s.urgency", citystr, aitstr);
1172
1173 /* avoid fc_rand recalculations on subsequent reload. */
1174 city_data->building_turn
1175 = secfile_lookup_int_default(file, 0, "%s.%s.building_turn", citystr,
1176 aitstr);
1177 city_data->building_wait
1179 "%s.%s.building_wait", citystr, aitstr);
1180
1181 /* avoid fc_rand and expensive recalculations on subsequent reload. */
1182 city_data->founder_turn
1183 = secfile_lookup_int_default(file, 0, "%s.%s.founder_turn", citystr,
1184 aitstr);
1185 city_data->founder_want
1186 = secfile_lookup_int_default(file, 0, "%s.%s.founder_want", citystr,
1187 aitstr);
1188 city_data->founder_boat
1189 = secfile_lookup_bool_default(file, (city_data->founder_want < 0),
1190 "%s.%s.founder_boat", citystr, aitstr);
1191}
1192
1193/**********************************************************************/
1206 const struct city *pcity)
1207{
1208 struct action *paction = action_by_number(act_id);
1209
1211 "Action %d don't exist.", act_id);
1212
1214 /* Not city targeted in this ruleset. */
1215 return 0;
1216 }
1217
1218 switch (paction->result) {
1220 /* Copied from the evaluation of the No_Incite effect */
1221 return MAX((game.server.diplchance * 2
1224 - game.server.incite_unit_factor * 5, 0);
1225
1226 /* Really bad for the city owner. */
1227 case ACTRES_SPY_NUKE:
1229 /* The ai will never destroy their own city to keep it out of enemy
1230 * hands. If it starts supporting it this value should change. */
1232 return 20;
1233
1234 /* Bad for the city owner. */
1235 case ACTRES_SPY_POISON:
1243 case ACTRES_NUKE:
1244 /* TODO: Individual and well balanced values */
1245 return 10;
1246
1247 /* Good for an enemy */
1250 case ACTRES_STEAL_MAPS:
1251 /* TODO: Individual and well balanced values */
1252 return 8;
1253
1254 /* Could be worse */
1257 case ACTRES_MARKETPLACE:
1258 case ACTRES_SPY_ESCAPE:
1259 /* TODO: Individual and well balanced values */
1260 return 1;
1261
1262 /* Good for the city owner in most cases. */
1263 case ACTRES_TRADE_ROUTE:
1264 case ACTRES_HELP_WONDER:
1265 case ACTRES_JOIN_CITY:
1267 case ACTRES_HOME_CITY:
1269 case ACTRES_AIRLIFT:
1270 /* TODO: Individual and well balanced values */
1271 return -1;
1272
1273 /* Ruleset defined actions. We have no idea what they do. */
1274 case ACTRES_NONE:
1275 return 0;
1276
1277 /* Shouldn't happen. */
1279 /* Against the tile so potential city effects are overlooked for now. */
1282 case ACTRES_SPY_ATTACK:
1283 case ACTRES_EXPEL_UNIT:
1286 case ACTRES_BOMBARD:
1287 case ACTRES_FOUND_CITY:
1288 case ACTRES_NUKE_UNITS:
1289 case ACTRES_PARADROP:
1290 case ACTRES_ATTACK:
1291 case ACTRES_WIPE_UNITS:
1293 case ACTRES_HEAL_UNIT:
1295 case ACTRES_CULTIVATE:
1296 case ACTRES_PLANT:
1297 case ACTRES_PILLAGE:
1298 case ACTRES_CLEAN:
1299 case ACTRES_FORTIFY:
1300 case ACTRES_ROAD:
1301 case ACTRES_CONVERT:
1302 case ACTRES_BASE:
1303 case ACTRES_MINE:
1304 case ACTRES_IRRIGATE:
1312 case ACTRES_HUT_ENTER:
1314 case ACTRES_UNIT_MOVE:
1315 case ACTRES_TELEPORT:
1317 case ACTRES_HOMELESS:
1319
1320 case ACTRES_UNUSED_1:
1322 "Action not aimed at cities");
1323 break;
1324 }
1325
1326 /* Wrong action. Ignore it. */
1327 return 0;
1328}
1329
1330/**********************************************************************/
1339static bool adjust_wants_for_reqs(struct ai_type *ait,
1340 struct player *pplayer,
1341 struct city *pcity,
1342 const struct impr_type *pimprove,
1343 const adv_want v)
1344{
1345 bool all_met = TRUE;
1346 int n_needed_techs = 0;
1347 int n_needed_improvements = 0;
1350
1351 const struct req_context context = {
1352 .player = pplayer,
1353 .city = pcity,
1354 .tile = city_tile(pcity),
1355 .building = pimprove,
1356 };
1357
1360
1361 requirement_vector_iterate(&pimprove->reqs, preq) {
1362 const bool active = is_req_active(&context, NULL, preq, RPT_POSSIBLE);
1363
1364 if (VUT_ADVANCE == preq->source.kind && preq->present && !active) {
1365 /* Found a missing technology requirement for this improvement. */
1366 tech_vector_append(&needed_techs, preq->source.value.advance);
1367 } else if (VUT_IMPROVEMENT == preq->source.kind && preq->present && !active) {
1368 /* Found a missing improvement requirement for this improvement.
1369 * For example, in the default ruleset a city must have a Library
1370 * before it can have a University. */
1371 impr_vector_append(&needed_improvements, preq->source.value.building);
1372 }
1373 all_met = all_met && active;
1375
1376 /* If v is negative, the improvement is not worth building,
1377 * but there is no need to punish research of the technologies
1378 * that would make it available.
1379 */
1381 if (0 < v && 0 < n_needed_techs) {
1382 /* Tell AI module how much we want this improvement and what techs are
1383 * required to get it. */
1384 const adv_want dv = v / n_needed_techs;
1385
1386 want_techs_for_improvement_effect(ait, pplayer, pcity, pimprove,
1387 &needed_techs, dv);
1388 }
1389
1390 /* If v is negative, the improvement is not worth building,
1391 * but there is no need to punish building the improvements
1392 * that would make it available.
1393 */
1395 if (0 < v && 0 < n_needed_improvements) {
1396 /* Because we want this improvement,
1397 * we want the improvements that will make it possible */
1398 const adv_want dv = v / (n_needed_improvements * 4); /* WAG */
1399 int i;
1400
1401 for (i = 0; i < n_needed_improvements; i++) {
1403 /* TODO: increase the want for the needed_impr,
1404 * if we can build it now */
1405 /* Recurse */
1406 (void) adjust_wants_for_reqs(ait, pplayer, pcity, needed_impr, dv);
1407 }
1408 }
1409
1410 /* TODO: use a similar method to increase wants for governments
1411 * that will make this improvement possible? */
1412
1415
1416 return all_met;
1417}
1418
1419/**********************************************************************/
1424adv_want dai_city_want(struct player *pplayer, struct city *acity,
1425 struct adv_data *adv, struct impr_type *pimprove)
1426{
1427 adv_want want = 0;
1428 int prod[O_LAST], bonus[O_LAST], waste[O_LAST];
1429 const struct civ_map *nmap = &(wld.map);
1430
1431 memset(prod, 0, O_LAST * sizeof(*prod));
1432 if (NULL != pimprove
1433 && adv->impr_calc[improvement_index(pimprove)] == ADV_IMPR_CALCULATE_FULL) {
1434 struct tile *acenter = city_tile(acity);
1436
1437 /* The below calculation mostly duplicates get_worked_tile_output().
1438 * We do this only for buildings that we know may change tile
1439 * outputs. */
1441 if (tile_worked(ptile) == acity) {
1443 prod[o] += city_tile_output(acity, ptile, celebrating, o);
1445 }
1447
1449 } else {
1450 fc_assert(sizeof(*prod) == sizeof(*acity->citizen_base));
1451 memcpy(prod, acity->citizen_base, O_LAST * sizeof(*prod));
1452 }
1453
1455 prod[O_TRADE] += proute->value;
1460 waste[o] = city_waste(acity, o, prod[o] * bonus[o] / 100, NULL);
1462 add_tax_income(pplayer,
1463 prod[O_TRADE] * bonus[O_TRADE] / 100 - waste[O_TRADE],
1464 prod);
1466 prod[o] = prod[o] * bonus[o] / 100 - waste[o];
1468
1472 /* Unit upkeep isn't handled here. Unless we do a full city_refresh it
1473 * won't be changed anyway. */
1474
1475 want += prod[O_FOOD] * adv->food_priority;
1476 if (prod[O_SHIELD] != 0) {
1477 want += prod[O_SHIELD] * adv->shield_priority;
1478 want -= city_pollution(acity, prod[O_SHIELD]) * adv->pollution_priority;
1479 }
1480 want += prod[O_LUXURY] * adv->luxury_priority;
1481 want += prod[O_SCIENCE] * adv->science_priority;
1482 if (pplayer->economic.tax > 50) {
1483 /* Increased tax rate indicates that we've had gold shortage which
1484 * we are trying to fill with taxes. Consider gold more critical
1485 * than usually.
1486 * Smallest tax rate we can have here is 60% -> factor (60 - 40) / 14.0 = 1.43 */
1487 want += prod[O_GOLD] * adv->gold_priority * (pplayer->economic.tax - 40) / 14.0;
1488 } else {
1489 want += prod[O_GOLD] * adv->gold_priority;
1490 }
1491
1492 return want;
1493}
1494
1495/**********************************************************************/
1499static adv_want base_want(struct ai_type *ait, struct player *pplayer,
1500 struct city *pcity, struct impr_type *pimprove)
1501{
1502 struct adv_data *adv = adv_data_get(pplayer, NULL);
1503 adv_want final_want = 0;
1506
1507 if (adv->impr_calc[improvement_index(pimprove)] == ADV_IMPR_ESTIMATE) {
1508 return 0; /* Nothing to calculate here. */
1509 }
1510
1511 if (!can_city_build_improvement_now(pcity, pimprove)
1512 || (is_small_wonder(pimprove)
1513 && NULL != city_from_small_wonder(pplayer, pimprove))) {
1514 return 0;
1515 }
1516
1517 if (is_wonder(pimprove)) {
1518 if (is_great_wonder(pimprove)) {
1521 }
1522 wonder_city_id = pplayer->wonders[improvement_index(pimprove)];
1523 }
1524 /* Add the improvement */
1525 city_add_improvement(pcity, pimprove);
1526
1527 /* Stir, then compare notes */
1528 city_range_iterate(pcity, pplayer->cities,
1529 adv->impr_range[improvement_index(pimprove)], acity) {
1530 final_want += dai_city_want(pplayer, acity, adv, pimprove)
1531 - def_ai_city_data(acity, ait)->worth;
1533
1534 /* Restore */
1535 city_remove_improvement(pcity, pimprove);
1536 if (is_wonder(pimprove)) {
1537 if (is_great_wonder(pimprove)) {
1540 }
1541
1542 pplayer->wonders[improvement_index(pimprove)] = wonder_city_id;
1543 }
1544
1545 return final_want;
1546}
1547
1548/**********************************************************************/
1578 struct player *pplayer,
1579 struct city *pcity,
1580 struct impr_type *pimprove,
1581 const bool already)
1582{
1583 adv_want v = 0;
1585 int nplayers = normal_player_count();
1586 struct adv_data *ai = adv_data_get(pplayer, NULL);
1587 bool capital = is_capital(pcity);
1588 bool can_build = TRUE;
1589 struct universal source = {
1591 .value = {.building = pimprove}
1592 };
1593 const bool is_convert = is_convert_improvement(pimprove);
1594 int turns = 9999;
1595 int place = tile_continent(pcity->tile);
1596
1597 /* FIXME: Do we really need the effects check to be made *without*
1598 * passing the city tile? */
1599 const struct req_context effect_ctxt = {
1600 .player = pplayer,
1601 .city = pcity,
1602 .building = pimprove,
1603 };
1604
1605 /* Do NOT pass building here, as the action might be about
1606 * targeting some completely different building, AND
1607 * the check to see if the action is possible before
1608 * the building is there is also ignoring the buildings.
1609 * We don't want those two results to differ for
1610 * an unrelated reason to what we are evaluating. */
1611 const struct req_context actenabler_ctxt = {
1612 .player = pplayer,
1613 .city = pcity,
1614 .tile = city_tile(pcity),
1615 };
1616
1617 /* Remove team members from the equation */
1619 if (aplayer->team
1620 && aplayer->team == pplayer->team
1621 && aplayer != pplayer) {
1622 nplayers--;
1623 }
1625
1626 if (is_convert) {
1627 /* Since coinage-like improvements contains some entirely spurious
1628 * ruleset values, we need to hard-code a sensible want.
1629 * We must otherwise handle IG_CONVERT improvements like the others,
1630 * so the AI will research techs that make it available,
1631 * for rulesets that do not provide it from the start.
1632 */
1633 if (improvement_has_flag(pimprove, IF_GOLD)) {
1634 v += TRADE_WEIGHTING / 10;
1635 }
1636 /* Without relevant flags, base want remains 0. */
1637 } else {
1638 /* Base want is calculated above using a more direct approach. */
1639 v += base_want(ait, pplayer, pcity, pimprove);
1640 if (v != 0) {
1641 CITY_LOG(LOG_DEBUG, pcity, "%s base_want is " ADV_WANT_PRINTF " (range=%d)",
1642 improvement_rule_name(pimprove),
1643 v,
1644 ai->impr_range[improvement_index(pimprove)]);
1645 }
1646 }
1647
1648 if (!is_convert) {
1649 /* Adjust by building cost */
1650 /* FIXME: ought to reduce by upkeep cost and amortise by building cost */
1651 v -= (impr_build_shield_cost(pcity, pimprove)
1652 / (pcity->surplus[O_SHIELD] * 10 + 1));
1653 }
1654
1655 /* Find number of cities per range. */
1657 /* kludge -- Number of *our* cities in these ranges. */
1660
1661 if (place < 0) {
1663 } else {
1665 }
1666
1667 /* All the trade partners and the city being considered. */
1669
1671
1672 /* Invalid building range */
1674 = cities[REQ_RANGE_TILE] = 0;
1675
1677 int potential = (aplayer->server.bulbs_last_turn
1678 + city_list_size(aplayer->cities) + 1);
1679
1680 if (potential > 0) {
1682 if (pobs->source.kind == VUT_ADVANCE && pobs->present) {
1683 turns = MIN(turns,
1685 advance_number(pobs->source.value.advance))
1686 / (potential + 1));
1687 }
1689 }
1691
1694 bool active = TRUE;
1695 int n_needed_techs = 0;
1697 bool present = TRUE;
1698 bool impossible_to_get = FALSE;
1699
1701
1703 /* Check if all the requirements for the currently evaluated effect
1704 * are met, except for having the building that we are evaluating. */
1706 if (preq->range < range) {
1707 /* More limited range */
1708 range = preq->range;
1709 }
1710 present = preq->present;
1711 continue;
1712 }
1713
1715 active = FALSE;
1716 if (VUT_ADVANCE == preq->source.kind && preq->present) {
1717 /* This missing requirement is a missing tech requirement.
1718 * This will be for some additional effect
1719 * (For example, in the default ruleset, Mysticism increases
1720 * the effect of Temples). */
1721 tech_vector_append(&needed_techs, preq->source.value.advance);
1722 } else if (!dai_can_requirement_be_met_in_city(preq, pplayer, pcity)) {
1724 }
1725 }
1727
1729 if ((active || n_needed_techs) && !impossible_to_get) {
1730 adv_want v1 = dai_effect_value(pplayer, ai, pcity, capital,
1731 turns, peffect, range, nplayers);
1732 /* v1 could be negative (the effect could be undesirable),
1733 * although it is usually positive.
1734 * For example, in the default ruleset, Communism decreases the
1735 * effectiveness of a Cathedral. */
1736
1737 if (!present) {
1738 /* Building removes the effect */
1739 /* Currently v1 is (v + delta). Make it (v - delta) instead */
1740 v1 = -v1;
1741 }
1742
1743 if (active) {
1744 v += v1;
1745 } else if (v1 > 0) {
1746 /* If value of the effect is negative, do not hold it against
1747 * the tech - having the tech wont force one to build the
1748 * building. */
1749
1750 /* We might want the technology that will enable this
1751 * (additional) effect.
1752 * The better the effect, the more we want the technology.
1753 * We are more interested in (additional) effects that enhance
1754 * buildings we already have.
1755 */
1756 const int a = already? 5: 4; /* WAG */
1757 const adv_want dv = v1 * a / (4 * n_needed_techs);
1758
1759 want_techs_for_improvement_effect(ait, pplayer, pcity, pimprove,
1760 &needed_techs, dv);
1761 }
1762 }
1763
1766
1767 /* Can the city be the target of an action? */
1768 action_iterate (act_id) {
1769 bool is_possible;
1770 bool will_be_possible = FALSE;
1771 enum req_range max_range;
1772 int act_neg_util;
1773
1774 /* Is the action relevant? */
1775 if (action_id_get_target_kind(act_id) != ATK_CITY) {
1776 continue;
1777 }
1778
1779 /* No range found yet. Local is the most narrow range. */
1781
1782 /* Is it possible to do the action to the city right now?
1783 *
1784 * (DiplRel requirements are ignored since actor_player is NULL) */
1786
1787 /* Will it be possible to do the action to the city if the building is
1788 * built? */
1790 enabler) {
1791 bool active = TRUE;
1793
1794 requirement_vector_iterate(&(enabler->target_reqs), preq) {
1796 /* Pretend the building is there */
1797 if (preq->present) {
1798 range = preq->range; /* Assumption: Max one pr vector */
1799 continue;
1800 } else {
1801 active = FALSE;
1802 break;
1803 }
1805 active = FALSE;
1806 break;
1807 }
1809
1810 if (active) {
1812
1813 /* Store the widest range that enables the action. */
1814 if (max_range < range) {
1815 max_range = range;
1816 }
1817
1818 /* Don't break the iteration even if the action is enabled. There
1819 * could be a wider range in an active action enabler not yet seen.
1820 */
1821 }
1823
1824 /* Will the building significantly change the ability to target
1825 * the city? */
1827 continue;
1828 }
1829
1830 /* How undesirable is it that the city may be a target? */
1831 act_neg_util = action_target_neg_util(act_id, pcity);
1832
1833 /* Multiply the desire by number of cities in range.
1834 * Note: This is a simplification. If the action can be done or not
1835 * _may_ be uncanged or changed in the opposite direction in the other
1836 * cities in the range. */
1838
1839 /* Consider the utility of being a potential target.
1840 * Remember: act_util is the negative utility of being a target. */
1841 if (will_be_possible) {
1842 v -= act_neg_util;
1843 } else {
1844 v += act_neg_util;
1845 }
1847
1848 if (already) {
1849 /* Discourage research of the technology that would make this building
1850 * obsolete. The bigger the desire for this building, the more
1851 * we want to discourage the technology. */
1852 dont_want_tech_obsoleting_impr(ait, pplayer, pcity, pimprove, v);
1853 } else {
1854 /* Increase the want for technologies that will enable
1855 * construction of this improvement, if necessary.
1856 */
1857 const bool all_met = adjust_wants_for_reqs(ait, pplayer, pcity, pimprove, v);
1859 }
1860
1861 if (is_convert && can_build) {
1862 /* Could have a negative want for coinage-like improvements,
1863 * if we have some stock in a building already. */
1864 pcity->server.adv->building_want[improvement_index(pimprove)] += v;
1865 } else if (!already && can_build) {
1866 const struct research *presearch = research_get(pplayer);
1867
1868 /* Convert the base 'want' into a building want
1869 * by applying various adjustments */
1870
1871 /* Would it mean losing shields? */
1872 if ((VUT_UTYPE == pcity->production.kind
1874 && !is_wonder(pimprove))
1875 || (!is_wonder(pcity->production.value.building)
1876 && is_wonder(pimprove)))
1877 && pcity->turn_last_built != game.info.turn) {
1878 if (has_handicap(pplayer, H_PRODCHGPEN)) {
1879 v -= pcity->shield_stock * SHIELD_WEIGHTING / 4;
1880 } else {
1881 v -= pcity->shield_stock * SHIELD_WEIGHTING / 15;
1882 }
1883 }
1884
1885 /* Reduce want if building gets obsoleted soon */
1887 if (pobs->source.kind == VUT_ADVANCE && pobs->present) {
1889 advance_number(pobs->source.value.advance));
1890
1891 v -= v / MAX(1, num_tech);
1892 }
1894
1895 /* Are we wonder city? Try to avoid building non-wonders very much. */
1896 if (pcity->id == ai->wonder_city && !is_wonder(pimprove)) {
1897 v /= 5;
1898 }
1899
1900 /* Set */
1901 pcity->server.adv->building_want[improvement_index(pimprove)] += v;
1902 }
1903 /* Else we either have the improvement already,
1904 * or we can not build it (yet) */
1905}
1906
1907/**********************************************************************/
1916static bool should_force_recalc(struct city *pcity)
1917{
1918 return city_built_last_turn(pcity)
1919 || (VUT_IMPROVEMENT == pcity->production.kind
1922 (pcity, pcity->production.value.building));
1923}
1924
1925/**********************************************************************/
1929void dai_build_adv_init(struct ai_type *ait, struct player *pplayer)
1930{
1931 struct adv_data *ai = adv_data_get(pplayer, NULL);
1932
1933 /* Find current worth of cities and cache this. */
1934 city_list_iterate(pplayer->cities, pcity) {
1935 def_ai_city_data(pcity, ait)->worth = dai_city_want(pplayer, pcity, ai, NULL);
1937}
1938
1939/**********************************************************************/
1945void dai_build_adv_adjust(struct ai_type *ait, struct player *pplayer,
1946 struct city *wonder_city)
1947{
1948 /* Clear old building wants.
1949 * Do this separately from the iteration over improvement types
1950 * because each iteration could actually update more than one improvement,
1951 * if improvements have improvements as requirements.
1952 */
1953 city_list_iterate(pplayer->cities, pcity) {
1954 struct ai_city *city_data = def_ai_city_data(pcity, ait);
1955
1956 if (city_data->building_turn <= game.info.turn) {
1957 /* Do a scheduled recalculation this turn */
1958 improvement_iterate(pimprove) {
1959 pcity->server.adv->building_want[improvement_index(pimprove)] = 0;
1961 } else if (should_force_recalc(pcity)) {
1962 /* Do an emergency recalculation this turn. */
1963 city_data->building_wait = city_data->building_turn
1964 - game.info.turn;
1965 city_data->building_turn = game.info.turn;
1966
1967 improvement_iterate(pimprove) {
1968 pcity->server.adv->building_want[improvement_index(pimprove)] = 0;
1970 }
1972
1973 improvement_iterate(pimprove) {
1974 if (can_player_build_improvement_later(pplayer, pimprove)) {
1975 city_list_iterate(pplayer->cities, pcity) {
1976 struct ai_city *city_data = def_ai_city_data(pcity, ait);
1977
1978 if (pcity != wonder_city && is_wonder(pimprove)) {
1979 /* Only wonder city should build wonders! */
1980 pcity->server.adv->building_want[improvement_index(pimprove)] = 0;
1981 } else if (city_data->building_turn <= game.info.turn) {
1982 /* Building wants vary relatively slowly, so not worthwhile
1983 * recalculating them every turn.
1984 * We DO want to calculate (tech) wants because of buildings
1985 * we already have. */
1986 const bool already = city_has_building(pcity, pimprove);
1987 int idx = improvement_index(pimprove);
1988
1989 adjust_improvement_wants_by_effects(ait, pplayer, pcity,
1990 pimprove, already);
1991
1993 && 0 < pcity->server.adv->building_want[idx]));
1994
1995 if (is_great_wonder(pimprove)) {
1996 /* Not only would we get the wonder, but we would also prevent
1997 * opponents from getting it. */
1998 pcity->server.adv->building_want[idx] *= 1.5;
1999
2000 if (pcity->production.kind == VUT_IMPROVEMENT
2001 && is_great_wonder(pcity->production.value.building)) {
2002 /* If we already are building a great wonder, prefer continuing
2003 * to do so over stopping it */
2004 pcity->server.adv->building_want[idx] *= 1.25;
2005 }
2006 }
2007
2008 /* If I am not an expansionist, I want buildings more than units */
2009 if (pcity->server.adv->building_want[idx] > 0) {
2010 pcity->server.adv->building_want[idx]
2011 = pcity->server.adv->building_want[idx]
2014 }
2015 }
2016 /* else wait until a later turn */
2018 } else {
2019 /* An impossible improvement */
2020 city_list_iterate(pplayer->cities, pcity) {
2021 pcity->server.adv->building_want[improvement_index(pimprove)] = 0;
2023 }
2025
2026#ifdef FREECIV_DEBUG
2027 /* This logging is relatively expensive, so activate only if necessary */
2028 city_list_iterate(pplayer->cities, pcity) {
2029 improvement_iterate(pimprove) {
2030 if (pcity->server.adv->building_want[improvement_index(pimprove)] != 0) {
2031 CITY_LOG(LOG_DEBUG, pcity, "want to build %s with " ADV_WANT_PRINTF,
2032 improvement_rule_name(pimprove),
2033 pcity->server.adv->building_want[improvement_index(pimprove)]);
2034 }
2037#endif /* FREECIV_DEBUG */
2038
2039 /* Reset recalc counter */
2040 city_list_iterate(pplayer->cities, pcity) {
2041 struct ai_city *city_data = def_ai_city_data(pcity, ait);
2042
2043 if (city_data->building_turn <= game.info.turn) {
2044 /* This will spread recalcs out so that no one turn end is
2045 * much longer than others */
2047 city_data->building_turn = game.info.turn
2048 + city_data->building_wait;
2049 }
2051}
2052
2053/**********************************************************************/
2056void dai_consider_wonder_city(struct ai_type *ait, struct city *pcity, bool *result)
2057{
2058 if (def_ai_city_data(pcity, ait)->grave_danger > 0) {
2059 *result = FALSE;
2060 } else {
2061 *result = TRUE;
2062 }
2063}
2064
2065/**********************************************************************/
2069static bool dai_cant_help_req(const struct req_context *context,
2070 const struct requirement *req)
2071{
2072 switch (req->source.kind) {
2073 /* Unskilled in channel digging and merchantry */
2074 case VUT_TERRAIN:
2075 case VUT_EXTRA:
2076 case VUT_GOOD:
2077 case VUT_TERRAINCLASS:
2078 case VUT_TERRFLAG:
2079 case VUT_TERRAINALTER:
2080 case VUT_CITYTILE:
2081 return !is_req_active(context, NULL, req, RPT_POSSIBLE);
2082 default:
2084 }
2085}
2086
2087/**********************************************************************/
2091 const struct impr_type *pimprove)
2092{
2093 const struct req_context city_ctxt = {
2094 .player = city_owner(pcity),
2095 .city = pcity,
2096 .tile = city_tile(pcity),
2097 };
2098
2099 /* FIXME: AI may be too stupid to sell obsoleting improvements
2100 * from the city that are _not_ checked here. */
2102 pimprove)) {
2103 return FALSE;
2104 }
2105 /* Check for requirements that aren't met and that are unchanging (so
2106 * they can never be met). */
2107 requirement_vector_iterate(&pimprove->reqs, preq) {
2109 return FALSE;
2110 }
2112
2113 return TRUE;
2114}
2115
2116/**********************************************************************/
2119bool
2121 const struct impr_type *pimprove)
2122{
2123 const struct req_context context = { .player = p };
2124
2125 if (!valid_improvement(pimprove)) {
2126 return FALSE;
2127 }
2128 if (improvement_obsolete(p, pimprove, NULL)) {
2129 return FALSE;
2130 }
2131 if (is_great_wonder(pimprove) && !great_wonder_is_available(pimprove)) {
2132 /* Can't build wonder if already built */
2133 return FALSE;
2134 }
2135
2136 /* Check for requirements that aren't met and that are unchanging (so
2137 * they can never be met). */
2138 requirement_vector_iterate(&pimprove->reqs, preq) {
2139 if (preq->range >= REQ_RANGE_PLAYER
2141 return FALSE;
2142 }
2144 /* FIXME: should check some "unchanging" reqs here - like if there's
2145 * a nation requirement, we can go ahead and check it now. */
2146
2147 return TRUE;
2148}
2149
2150/**********************************************************************/
2157 enum effect_type effect_type,
2158 const struct unit_type *utype)
2159{
2160 int greatest_value = 0;
2161 const struct impr_type *best_building = NULL;
2162 const struct req_context context = {
2163 .player = city_owner(pcity),
2164 .city = pcity,
2165 .tile = city_tile(pcity),
2166 .unittype = utype,
2167 };
2168
2169 effect_list_iterate(get_effects(effect_type), peffect) {
2170 if (peffect->value > greatest_value) {
2171 const struct impr_type *building = NULL;
2172 bool wrong_unit = FALSE;
2173
2175 if (VUT_IMPROVEMENT == preq->source.kind && preq->present) {
2176 building = preq->source.value.building;
2177
2178 if (!can_city_build_improvement_now(pcity, building)
2179 || !is_improvement(building)) {
2180 building = NULL;
2181 break;
2182 }
2183 } else if (VUT_IMPR_FLAG == preq->source.kind && preq->present) {
2184 /* TODO: Ruleset cache for buildings with specific flag */
2185 improvement_iterate(impr) {
2186 if (improvement_has_flag(impr, preq->source.value.impr_flag)) {
2187 if (can_city_build_improvement_now(pcity, impr)
2188 && is_improvement(impr)) {
2189 if (building == NULL) {
2190 building = impr;
2191 break;
2192 }
2193 }
2194 }
2196
2197 if (building == NULL) {
2198 break;
2199 }
2200 } else if (utype != NULL
2202 /* Effect requires other kind of unit than what we are interested about */
2203 wrong_unit = TRUE;
2204 break;
2205 }
2207 if (!wrong_unit && building != NULL) {
2208 best_building = building;
2209 greatest_value = peffect->value;
2210 }
2211 }
2213
2214 if (best_building) {
2216 }
2217 return B_LAST;
2218}
bool is_action_possible_on_city(action_id act_id, const struct player *actor_player, const struct city *target_city)
Definition actions.c:6216
void action_array_add_all_by_result(action_id *act_array, int *position, enum action_result result)
Definition actions.c:6488
void action_array_end(action_id *act_array, int size)
Definition actions.c:6471
bool is_action_enabled_unit_on_self(const action_id wanted_action, const struct unit *actor_unit)
Definition actions.c:4223
bool action_ever_possible(action_id action)
Definition actions.c:8081
bool is_action_enabled_unit_on_city(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *target_city)
Definition actions.c:3832
bool action_id_exists(const action_id act_id)
Definition actions.c:1820
enum action_target_kind action_get_target_kind(const struct action *paction)
Definition actions.c:1860
struct action_enabler_list * action_enablers_for_action(action_id action)
Definition actions.c:2306
static struct action * action_by_number(action_id act_id)
Definition actions.h:633
#define action_array_iterate(_act_array_, _act_id_)
Definition actions.h:495
#define action_enabler_list_iterate_end
Definition actions.h:439
#define action_id_get_role(act_id)
Definition actions.h:694
#define action_array_iterate_end
Definition actions.h:507
#define action_iterate_end
Definition actions.h:463
#define MAX_NUM_ACTIONS
Definition actions.h:312
#define action_enabler_list_iterate(action_enabler_list, aenabler)
Definition actions.h:437
#define action_iterate(_act_)
Definition actions.h:459
#define action_id_get_target_kind(act_id)
Definition actions.h:650
void building_advisor(struct player *pplayer)
#define TRADE_WEIGHTING
Definition advbuilding.h:21
#define FOOD_WEIGHTING
Definition advbuilding.h:19
#define SHIELD_WEIGHTING
Definition advbuilding.h:20
void adv_deinit_choice(struct adv_choice *choice)
Definition advchoice.c:46
void adv_init_choice(struct adv_choice *choice)
Definition advchoice.c:31
void adv_free_choice(struct adv_choice *choice)
Definition advchoice.c:71
struct adv_choice * adv_better_choice(struct adv_choice *first, struct adv_choice *second)
Definition advchoice.c:85
bool is_unit_choice_type(enum choice_type type)
Definition advchoice.c:115
const char * adv_choice_rule_name(const struct adv_choice *choice)
Definition advchoice.c:124
#define adv_choice_set_use(_choice, _use)
Definition advchoice.h:85
#define ADV_CHOICE_ASSERT(c)
Definition advchoice.h:100
static void adv_choice_copy(struct adv_choice *dest, struct adv_choice *src)
Definition advchoice.h:79
@ CT_CIVILIAN
Definition advchoice.h:39
@ CT_LAST
Definition advchoice.h:42
@ CT_DEFENDER
Definition advchoice.h:41
@ CT_ATTACKER
Definition advchoice.h:40
@ CT_NONE
Definition advchoice.h:37
@ CT_BUILDING
Definition advchoice.h:38
struct adv_data * adv_data_get(struct player *pplayer, bool *caller_closes)
Definition advdata.c:605
@ ADV_IMPR_CALCULATE_FULL
Definition advdata.h:35
@ ADV_IMPR_ESTIMATE
Definition advdata.h:36
void dai_calc_data(const struct player *pplayer, int *trade, int *expenses, int *income)
Definition aihand.c:117
int dai_gold_reserve(struct player *pplayer)
Definition aitools.c:1325
#define DAI_WANT_MILITARY_EMERGENCY
Definition aitools.h:32
int ai_trait_get_value(enum trait tr, struct player *pplayer)
Definition aitraits.c:69
adv_want settler_evaluate_improvements(const struct civ_map *nmap, struct unit *punit, enum unit_activity *best_act, struct extra_type **best_target, struct tile **best_tile, struct pf_path **path, struct settlermap *state)
bool base_city_celebrating(const struct city *pcity)
Definition city.c:1629
bool is_free_worked(const struct city *pcity, const struct tile *ptile)
Definition city.c:3589
int city_granary_size(int city_size)
Definition city.c:2123
void city_set_ai_data(struct city *pcity, const struct ai_type *ai, void *data)
Definition city.c:3605
bool city_built_last_turn(const struct city *pcity)
Definition city.c:2270
int city_waste(const struct city *pcity, Output_type_id otype, int total, int *breakdown)
Definition city.c:3216
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1231
bool is_capital(const struct city *pcity)
Definition city.c:1571
const char * city_name_get(const struct city *pcity)
Definition city.c:1128
void city_remove_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3359
int city_improvement_upkeep(const struct city *pcity, const struct impr_type *b)
Definition city.c:1246
void add_tax_income(const struct player *pplayer, int trade, int *output)
Definition city.c:2236
bool can_city_build_improvement_now(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:853
int get_city_tithes_bonus(const struct city *pcity)
Definition city.c:2218
bool city_unhappy(const struct city *pcity)
Definition city.c:1618
int get_final_city_output_bonus(const struct city *pcity, Output_type_id otype)
Definition city.c:2203
int city_pollution(const struct city *pcity, int shield_total)
Definition city.c:2812
void city_add_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3345
int city_map_radius_sq_get(const struct city *pcity)
Definition city.c:136
bool city_base_to_city_map(int *city_map_x, int *city_map_y, const struct city *const pcity, const struct tile *map_tile)
Definition city.c:280
void add_specialist_output(const struct city *pcity, int *output)
Definition city.c:2355
int city_tile_output(const struct city *pcity, const struct tile *ptile, bool is_celebrating, Output_type_id otype)
Definition city.c:1274
bool can_city_build_unit_now(const struct city *pcity, const struct unit_type *punittype)
Definition city.c:945
#define city_list_iterate(citylist, pcity)
Definition city.h:508
#define city_tile(_pcity_)
Definition city.h:564
static citizens city_size_get(const struct city *pcity)
Definition city.h:569
@ CITIZEN_ANGRY
Definition city.h:271
@ CITIZEN_UNHAPPY
Definition city.h:270
#define output_type_iterate(output)
Definition city.h:833
#define city_owner(_pcity_)
Definition city.h:563
#define city_list_iterate_end
Definition city.h:510
#define city_tile_iterate(_nmap, _radius_sq, _city_tile, _tile)
Definition city.h:230
@ FEELING_FINAL
Definition city.h:284
#define city_tile_iterate_end
Definition city.h:238
#define city_built_iterate(_pcity, _p)
Definition city.h:822
#define city_built_iterate_end
Definition city.h:828
#define output_type_iterate_end
Definition city.h:839
void really_handle_city_buy(struct player *pplayer, struct city *pcity)
Definition cityhand.c:293
void really_handle_city_sell(struct player *pplayer, struct city *pcity, struct impr_type *pimprove)
Definition cityhand.c:240
void city_map_update_empty(struct city *pcity, struct tile *ptile)
Definition citytools.c:3239
void city_freeze_workers_queue(struct city *pcity)
Definition citytools.c:161
int city_production_buy_gold_cost(const struct city *pcity)
Definition citytools.c:3610
void sync_cities(void)
Definition citytools.c:3313
void change_build_target(struct player *pplayer, struct city *pcity, struct universal *target, enum event_type event)
Definition citytools.c:3150
void do_sell_building(struct player *pplayer, struct city *pcity, struct impr_type *pimprove, const char *reason)
Definition citytools.c:2968
void city_thaw_workers_queue(void)
Definition citytools.c:193
int city_shrink_granary_savings(const struct city *pcity)
Definition cityturn.c:892
void auto_arrange_workers(struct city *pcity)
Definition cityturn.c:366
bool city_refresh(struct city *pcity)
Definition cityturn.c:159
char * incite_cost
Definition comments.c:74
static void try_to_sell_stuff(struct player *pplayer, struct city *pcity)
Definition daicity.c:353
#define AI_BA_RECALC_SPEED
Definition daicity.c:75
#define AI_CITY_RECALC_SPEED
Definition daicity.c:73
static bool adjust_wants_for_reqs(struct ai_type *ait, struct player *pplayer, struct city *pcity, const struct impr_type *pimprove, const adv_want v)
Definition daicity.c:1339
static void unit_do_disband_trad(struct player *owner, struct unit *punit, const enum action_requester requester)
Definition daicity.c:450
static bool dai_cant_help_req(const struct req_context *context, const struct requirement *req)
Definition daicity.c:2069
void want_techs_for_improvement_effect(struct ai_type *ait, struct player *pplayer, const struct city *pcity, const struct impr_type *pimprove, struct tech_vector *needed_techs, adv_want building_want)
Definition daicity.c:156
static void increase_maxbuycost(struct player *pplayer, int new_value)
Definition daicity.c:369
static void dai_barbarian_choose_build(struct player *pplayer, struct city *pcity, struct adv_choice *choice)
Definition daicity.c:200
void dai_city_save(struct ai_type *ait, const char *aitstr, struct section_file *file, const struct city *pcity, const char *citystr)
Definition daicity.c:1136
void dai_city_load(struct ai_type *ait, const char *aitstr, const struct section_file *file, struct city *pcity, const char *citystr)
Definition daicity.c:1163
#define LOG_BUY
Definition daicity.c:67
static void dai_city_sell_noncritical(struct city *pcity, bool redundant_only)
Definition daicity.c:985
#define city_range_iterate_end
Definition daicity.c:102
static int unit_food_upkeep(struct unit *punit)
Definition daicity.c:689
void dai_manage_cities(struct ai_type *ait, struct player *pplayer)
Definition daicity.c:849
void dai_city_alloc(struct ai_type *ait, struct city *pcity)
Definition daicity.c:1109
#define LOG_EMERGENCY
Definition daicity.c:68
void dai_consider_wonder_city(struct ai_type *ait, struct city *pcity, bool *result)
Definition daicity.c:2056
static bool should_force_recalc(struct city *pcity)
Definition daicity.c:1916
bool dai_can_player_build_improvement_later(const struct player *p, const struct impr_type *pimprove)
Definition daicity.c:2120
static int action_target_neg_util(action_id act_id, const struct city *pcity)
Definition daicity.c:1205
#define city_range_iterate(city_here, list, range, city)
Definition daicity.c:87
static void resolve_city_emergency(struct ai_type *ait, struct player *pplayer, struct city *pcity)
Definition daicity.c:1028
void dont_want_tech_obsoleting_impr(struct ai_type *ait, struct player *pplayer, const struct city *pcity, const struct impr_type *pimprove, adv_want building_want)
Definition daicity.c:177
void dai_build_adv_adjust(struct ai_type *ait, struct player *pplayer, struct city *wonder_city)
Definition daicity.c:1945
static void contemplate_terrain_improvements(struct ai_type *ait, struct city *pcity)
Definition daicity.c:747
static void dai_spend_gold(struct ai_type *ait, struct player *pplayer)
Definition daicity.c:521
#define LOG_WANT
Definition daicity.c:69
static void adjust_improvement_wants_by_effects(struct ai_type *ait, struct player *pplayer, struct city *pcity, struct impr_type *pimprove, const bool already)
Definition daicity.c:1577
void dai_city_free(struct ai_type *ait, struct city *pcity)
Definition daicity.c:1122
static void want_tech_for_improvement_effect(struct ai_type *ait, struct player *pplayer, const struct city *pcity, const struct impr_type *pimprove, const struct advance *tech, adv_want building_want)
Definition daicity.c:127
Impr_type_id dai_find_source_building(struct city *pcity, enum effect_type effect_type, const struct unit_type *utype)
Definition daicity.c:2156
void dai_build_adv_init(struct ai_type *ait, struct player *pplayer)
Definition daicity.c:1929
static void dai_upgrade_units(struct city *pcity, int limit, bool military)
Definition daicity.c:379
#define CITY_EMERGENCY(pcity)
Definition daicity.c:107
bool dai_can_city_build_improvement_later(const struct city *pcity, const struct impr_type *pimprove)
Definition daicity.c:2090
adv_want dai_city_want(struct player *pplayer, struct city *acity, struct adv_data *adv, struct impr_type *pimprove)
Definition daicity.c:1424
static adv_want base_want(struct ai_type *ait, struct player *pplayer, struct city *pcity, struct impr_type *pimprove)
Definition daicity.c:1499
static int unit_foodbox_cost(struct unit *punit)
Definition daicity.c:708
static bool building_crucial(const struct player *plr, struct impr_type *pimprove, const struct city *pcity)
Definition daicity.c:963
static void dai_city_choose_build(struct ai_type *ait, struct player *pplayer, struct city *pcity)
Definition daicity.c:249
#define BUILDING_WAIT_MINIMUM
Definition daicity.h:39
struct ai_plr * dai_plr_data_get(struct ai_type *ait, struct player *pplayer, bool *caller_closes)
Definition daidata.c:308
bool dai_on_war_footing(struct ai_type *ait, struct player *pplayer)
struct adv_choice * domestic_advisor_choose_build(struct ai_type *ait, struct player *pplayer, struct city *pcity)
bool dai_can_requirement_be_met_in_city(const struct requirement *preq, const struct player *pplayer, const struct city *pcity)
Definition daieffects.c:782
adv_want dai_effect_value(struct player *pplayer, const struct adv_data *adv, const struct city *pcity, const bool capital, int turns, const struct effect *peffect, const int c, const int nplayers)
Definition daieffects.c:138
#define TECH_LOG(ait, loglevel, pplayer, padvance, msg,...)
Definition dailog.h:36
int assess_defense(struct ai_type *ait, struct city *pcity)
int assess_defense_quadratic(struct ai_type *ait, struct city *pcity)
bool dai_process_defender_want(struct ai_type *ait, struct player *pplayer, struct city *pcity, unsigned int danger, struct adv_choice *choice, adv_want extra_want)
struct adv_choice * military_advisor_choose_build(struct ai_type *ait, struct player *pplayer, struct city *pcity, const struct civ_map *mamap, player_unit_list_getter ul_cb)
static struct ai_plr * def_ai_player_data(const struct player *pplayer, struct ai_type *deftype)
Definition daiplayer.h:54
static struct ai_city * def_ai_city_data(const struct city *pcity, struct ai_type *deftype)
Definition daiplayer.h:42
static struct unit_ai * def_ai_unit_data(const struct unit *punit, struct ai_type *deftype)
Definition daiplayer.h:48
void dai_auto_settler_reset(struct ai_type *ait, struct player *pplayer)
void contemplate_new_city(struct ai_type *ait, struct city *pcity)
struct unit_type * dai_role_utype_for_terrain_class(struct city *pcity, int role, enum terrain_class tc)
Definition daiunit.c:3427
#define IS_ATTACKER(ptype)
Definition daiunit.h:70
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:74
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit int cost
Definition dialogs_g.h:74
bool ai_fuzzy(const struct player *pplayer, bool normal_decision)
Definition difficulty.c:339
int get_city_bonus(const struct city *pcity, enum effect_type effect_type)
Definition effects.c:846
struct effect_list * get_effects(enum effect_type effect_type)
Definition effects.c:143
struct effect_list * get_req_source_effects(const struct universal *psource)
Definition effects.c:153
bool building_has_effect(const struct impr_type *pimprove, enum effect_type effect_type)
Definition effects.c:644
#define effect_list_iterate_end
Definition effects.h:406
#define effect_list_iterate(effect_list, peffect)
Definition effects.h:404
float adv_want
Definition fc_types.h:1355
int Impr_type_id
Definition fc_types.h:379
@ RPT_POSSIBLE
Definition fc_types.h:703
int action_id
Definition fc_types.h:392
#define ACTRES_NONE
Definition fc_types.h:330
#define ADV_WANT_PRINTF
Definition fc_types.h:1356
@ O_SHIELD
Definition fc_types.h:101
@ O_FOOD
Definition fc_types.h:101
@ O_TRADE
Definition fc_types.h:101
@ O_SCIENCE
Definition fc_types.h:101
@ O_LUXURY
Definition fc_types.h:101
@ O_GOLD
Definition fc_types.h:101
@ O_LAST
Definition fc_types.h:101
signed short Continent_id
Definition fc_types.h:375
#define PL_(String1, String2, n)
Definition fcintl.h:71
const struct ft_color ftc_server
const char * city_link(const struct city *pcity)
struct civ_game game
Definition game.c:62
struct world wld
Definition game.c:63
struct city * owner
Definition citydlg.c:220
static GtkWidget * source
Definition gotodlg.c:58
bool has_handicap(const struct player *pplayer, enum handicap_type htype)
Definition handicaps.c:66
@ H_AWAY
Definition handicaps.h:19
@ H_PRODCHGPEN
Definition handicaps.h:35
const struct impr_type * valid_improvement(const struct impr_type *pimprove)
int impr_sell_gold(const struct impr_type *pimprove)
bool can_city_sell_building(const struct city *pcity, const struct impr_type *pimprove)
bool is_improvement_redundant(const struct city *pcity, const struct impr_type *pimprove)
bool can_player_build_improvement_later(const struct player *p, const struct impr_type *pimprove)
bool is_improvement(const struct impr_type *pimprove)
Impr_type_id improvement_number(const struct impr_type *pimprove)
const char * improvement_rule_name(const struct impr_type *pimprove)
Impr_type_id improvement_index(const struct impr_type *pimprove)
int impr_build_shield_cost(const struct city *pcity, const struct impr_type *pimprove)
bool is_wonder(const struct impr_type *pimprove)
bool is_great_wonder(const struct impr_type *pimprove)
bool improvement_obsolete(const struct player *pplayer, const struct impr_type *pimprove, const struct city *pcity)
bool improvement_has_flag(const struct impr_type *pimprove, enum impr_flag_id flag)
struct city * city_from_small_wonder(const struct player *pplayer, const struct impr_type *pimprove)
bool is_convert_improvement(const struct impr_type *pimprove)
const char * improvement_name_translation(const struct impr_type *pimprove)
bool is_small_wonder(const struct impr_type *pimprove)
bool great_wonder_is_available(const struct impr_type *pimprove)
bool is_improvement_productive(const struct city *pcity, const struct impr_type *pimprove)
#define WONDER_NOT_OWNED
#define WONDER_NOT_BUILT
#define improvement_iterate_end
#define improvement_iterate(_p)
#define B_LAST
Definition improvement.h:42
void initialize_infrastructure_cache(struct player *pplayer)
Definition infracache.c:250
#define fc_assert_msg(condition, message,...)
Definition log.h:181
#define fc_assert_ret(condition)
Definition log.h:191
#define fc_assert(condition)
Definition log.h:176
#define fc_assert_ret_val(condition, val)
Definition log.h:194
#define fc_assert_action(condition, action)
Definition log.h:187
#define log_debug(message,...)
Definition log.h:115
#define log_normal(message,...)
Definition log.h:107
#define log_base(level, message,...)
Definition log.h:94
@ LOG_ERROR
Definition log.h:30
@ LOG_DEBUG
Definition log.h:34
#define fc_calloc(n, esz)
Definition mem.h:38
#define FC_FREE(ptr)
Definition mem.h:41
void notify_player(const struct player *pplayer, const struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition notify.c:292
struct city_list * cities
Definition packhand.c:119
int player_get_expected_income(const struct player *pplayer)
Definition player.c:1286
const char * player_name(const struct player *pplayer)
Definition player.c:895
#define players_iterate_end
Definition player.h:537
#define players_iterate(_pplayer)
Definition player.h:532
static bool is_barbarian(const struct player *pplayer)
Definition player.h:489
int normal_player_count(void)
Definition plrhand.c:3200
#define fc_rand(_size)
Definition rand.h:56
bool secfile_lookup_bool_default(const struct section_file *secfile, bool def, const char *path,...)
int secfile_lookup_int_default(const struct section_file *secfile, int def, const char *path,...)
#define secfile_insert_int(secfile, value, path,...)
#define secfile_insert_bool(secfile, value, path,...)
bool is_req_active(const struct req_context *context, const struct player *other_player, const struct requirement *req, const enum req_problem_type prob_type)
enum req_item_found universal_fulfills_requirement(const struct requirement *preq, const struct universal *source)
enum req_unchanging_status is_req_preventing(const struct req_context *context, const struct player *other_player, const struct requirement *req, enum req_problem_type prob_type)
#define requirement_vector_iterate_end
#define requirement_vector_iterate(req_vec, preq)
@ ITF_YES
#define REQ_RANGE_MAX
@ REQUCH_NO
int research_goal_unknown_techs(const struct research *presearch, Tech_type_id goal)
Definition research.c:750
int research_goal_bulbs_required(const struct research *presearch, Tech_type_id goal)
Definition research.c:772
struct research * research_get(const struct player *pplayer)
Definition research.c:128
#define CLIP(lower, current, upper)
Definition shared.h:57
#define MIN(x, y)
Definition shared.h:55
#define MAX(x, y)
Definition shared.h:54
#define DEFAULT_SPECIALIST
Definition specialist.h:43
size_t size
Definition specvec.h:72
#define CITY_LOG(loglevel, pcity, msg,...)
Definition srv_log.h:83
#define UNIT_LOG(loglevel, punit, msg,...)
Definition srv_log.h:98
@ AIT_CITY_MILITARY
Definition srv_log.h:63
@ AIT_BUILDINGS
Definition srv_log.h:51
@ AIT_CITY_TERRAIN
Definition srv_log.h:64
@ AIT_CITY_SETTLERS
Definition srv_log.h:65
@ AIT_EMERGENCY
Definition srv_log.h:62
@ TIMER_STOP
Definition srv_log.h:76
@ TIMER_START
Definition srv_log.h:76
#define TIMING_LOG(timer, activity)
Definition srv_log.h:125
enum choice_type type
Definition advchoice.h:46
adv_want want
Definition advchoice.h:48
universals_u value
Definition advchoice.h:47
adv_want building_want[B_LAST]
Definition infracache.h:32
int pollution_priority
Definition advdata.h:121
int shield_priority
Definition advdata.h:113
int * cities
Definition advdata.h:96
int * ocean_cities
Definition advdata.h:97
int luxury_priority
Definition advdata.h:115
int food_priority
Definition advdata.h:114
struct adv_data::@91 stats
enum adv_improvement_status impr_calc[B_LAST]
Definition advdata.h:58
int wonder_city
Definition advdata.h:55
enum req_range impr_range[B_LAST]
Definition advdata.h:59
int science_priority
Definition advdata.h:117
int gold_priority
Definition advdata.h:116
struct adv_choice choice
Definition daicity.h:41
int building_wait
Definition daicity.h:38
adv_want worth
Definition daicity.h:35
unsigned int grave_danger
Definition daicity.h:48
int * ocean_workers
Definition daidata.h:83
int * workers
Definition daidata.h:82
struct ai_plr::@251 stats
adv_want tech_want[A_LAST+1]
Definition daidata.h:103
Definition ai.h:50
void * private
Definition ai.h:53
Definition city.h:320
int turn_last_built
Definition city.h:387
int surplus[O_LAST]
Definition city.h:355
int id
Definition city.h:326
struct player * owner
Definition city.h:323
int anarchy
Definition city.h:384
struct universal production
Definition city.h:396
struct adv_city * adv
Definition city.h:452
citizens feel[CITIZEN_LAST][FEELING_LAST]
Definition city.h:333
struct tile * tile
Definition city.h:322
int shield_stock
Definition city.h:368
struct city::@17::@19 server
struct unit_list * units_supported
Definition city.h:406
int incite_total_factor
Definition game.h:150
int diplchance
Definition game.h:138
struct packet_game_info info
Definition game.h:89
int incite_improvement_factor
Definition game.h:149
struct civ_game::@31::@35 server
int incite_unit_factor
Definition game.h:151
struct requirement_vector obsolete_by
Definition improvement.h:59
struct requirement_vector reqs
Definition improvement.h:58
int great_wonder_owners[B_LAST]
int maxbuycost
Definition player.h:112
struct city_list * cities
Definition player.h:279
struct player_ai ai_common
Definition player.h:286
int wonders[B_LAST]
Definition player.h:303
struct team * team
Definition player.h:259
struct player_economic economic
Definition player.h:282
const struct player * player
struct universal source
Definition tile.h:50
struct unit_list * units
Definition tile.h:58
int pop_cost
Definition unittype.h:513
Definition unit.h:138
int id
Definition unit.h:145
int homecity
Definition unit.h:146
struct player * owner
Definition unit.h:143
enum universals_n kind
Definition fc_types.h:903
universals_u value
Definition fc_types.h:902
struct civ_map map
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
Tech_type_id advance_index(const struct advance *padvance)
Definition tech.c:89
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:98
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
#define tile_worked(_tile)
Definition tile.h:114
#define TILE_XY(ptile)
Definition tile.h:43
#define tile_continent(_tile)
Definition tile.h:92
int city_num_trade_routes(const struct city *pcity)
#define trade_routes_iterate_end
#define trade_routes_iterate(c, proute)
#define TRAIT_DEFAULT_VALUE
Definition traits.h:32
const struct unit_type * utype
Definition fc_types.h:724
const struct impr_type * building
Definition fc_types.h:717
bool unit_being_aggressive(const struct unit *punit)
Definition unit.c:1515
bool unit_is_alive(int id)
Definition unit.c:2249
bool is_field_unit(const struct unit *punit)
Definition unit.c:416
bool unit_can_do_action(const struct unit *punit, const action_id act_id)
Definition unit.c:361
struct unit * unit_virtual_create(struct player *pplayer, struct city *pcity, const struct unit_type *punittype, int veteran_level)
Definition unit.c:1620
const char * get_activity_text(enum unit_activity activity)
Definition unit.c:610
void unit_virtual_destroy(struct unit *punit)
Definition unit.c:1725
void unit_tile_set(struct unit *punit, struct tile *ptile)
Definition unit.c:1252
#define unit_tile(_pu)
Definition unit.h:390
#define unit_owner(_pu)
Definition unit.h:389
bool unit_perform_action(struct player *pplayer, const int actor_id, const int target_id, const int sub_tgt_id_incoming, const char *name, const action_id action_type, const enum action_requester requester)
Definition unithand.c:3311
void unit_do_action(struct player *pplayer, const int actor_id, const int target_id, const int sub_tgt_id, const char *name, const action_id action_type)
Definition unithand.c:3291
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
#define unit_list_iterate_safe(unitlist, _unit)
Definition unitlist.h:39
#define unit_list_iterate_end
Definition unitlist.h:33
#define unit_list_iterate_safe_end
Definition unitlist.h:61
struct unit_type * best_role_unit(const struct city *pcity, int role)
Definition unittype.c:2271
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
int utype_upkeep_cost(const struct unit_type *ut, struct player *pplayer, Output_type_id otype)
Definition unittype.c:132
bool utype_is_cityfounder(const struct unit_type *utype)
Definition unittype.c:2951
struct unit_type * get_role_unit(int role, int role_index)
Definition unittype.c:2253
const char * unit_rule_name(const struct unit *punit)
Definition unittype.c:1587
int num_role_units(int role)
Definition unittype.c:2203
const struct unit_type * can_upgrade_unittype(const struct player *pplayer, const struct unit_type *punittype)
Definition unittype.c:1703
const char * utype_rule_name(const struct unit_type *punittype)
Definition unittype.c:1578
bool unit_has_type_role(const struct unit *punit, enum unit_role_id role)
Definition unittype.c:208
bool unit_has_type_flag(const struct unit *punit, enum unit_type_flag_id flag)
Definition unittype.c:190
int utype_build_shield_cost(const struct city *pcity, const struct player *pplayer, const struct unit_type *punittype)
Definition unittype.c:1438
int utype_happy_cost(const struct unit_type *ut, const struct player *pplayer)
Definition unittype.c:181
int unit_upgrade_price(const struct player *pplayer, const struct unit_type *from, const struct unit_type *to)
Definition unittype.c:1731