/****************************************************************************
Return color for overview map tile.
****************************************************************************/
static struct color *overview_tile_color(struct tile *ptile)
{
if (overview.layers[OLAYER_CITIES]) {
struct city *pcity = tile_city(ptile);
if (pcity) {
if (NULL == client.conn.playing
|| city_owner(pcity) == client.conn.playing) {
return get_color(tileset, COLOR_OVERVIEW_MY_CITY);
} else if (pplayers_allied(city_owner(pcity), client.conn.playing)) {
/* Includes teams. */
return get_color(tileset, COLOR_OVERVIEW_ALLIED_CITY);
} else {
return get_color(tileset, COLOR_OVERVIEW_ENEMY_CITY);
}
}
}
if (overview.layers[OLAYER_UNITS]) {
struct unit *punit = find_visible_unit(ptile);
if (punit) {
if (NULL == client.conn.playing
|| unit_owner(punit) == client.conn.playing) {
return get_color(tileset, COLOR_OVERVIEW_MY_UNIT);
} else if (pplayers_allied(unit_owner(punit), client.conn.playing)) {
/* Includes teams. */
return get_color(tileset, COLOR_OVERVIEW_ALLIED_UNIT);
} else {
return get_color(tileset, COLOR_OVERVIEW_ENEMY_UNIT);
}
}
}
if (overview.layers[OLAYER_BORDERS]) {
struct player *owner = tile_owner(ptile);
if (owner) {
if (overview.layers[OLAYER_BORDERS_ON_OCEAN]) {
return get_player_color(tileset, owner);
} else if (!is_ocean_tile(ptile)) {
return get_player_color(tileset, owner);
}
}
}
if (overview.layers[OLAYER_RELIEF] && tile_terrain(ptile) != T_UNKNOWN) {
return get_terrain_color(tileset, tile_terrain(ptile));
}
if (overview.layers[OLAYER_BACKGROUND] && tile_terrain(ptile) != T_UNKNOWN) {
if (is_ocean_tile(ptile)) {
return get_color(tileset, COLOR_OVERVIEW_OCEAN);
} else {
return get_color(tileset, COLOR_OVERVIEW_LAND);
}
}
return get_color(tileset, COLOR_OVERVIEW_UNKNOWN);
}
/*****************************************************************************
Find best tile the paratrooper should jump to.
*****************************************************************************/
static struct tile *find_best_tile_to_paradrop_to(struct ai_type *ait,
struct unit *punit)
{
int best = 0;
int val;
struct tile* best_tile = NULL;
int range = unit_type(punit)->paratroopers_range;
struct city* acity;
struct player* pplayer = unit_owner(punit);
/* First, we search for undefended cities in danger */
square_iterate(unit_tile(punit), range, ptile) {
if (!map_is_known(ptile, pplayer)) {
continue;
}
acity = tile_city(ptile);
if (acity && city_owner(acity) == unit_owner(punit)
&& unit_list_size(ptile->units) == 0) {
val = city_size_get(acity) * def_ai_city_data(acity, ait)->urgency;
if (val > best) {
best = val;
best_tile = ptile;
}
}
} square_iterate_end;
if (best_tile != NULL) {
acity = tile_city(best_tile);
UNIT_LOG(LOGLEVEL_PARATROOPER, punit,
"Choose to jump in order to protect allied city %s (%d %d). "
"Benefit: %d",
city_name(acity), TILE_XY(best_tile), best);
return best_tile;
}
/* Second, we search for undefended enemy cities */
square_iterate(unit_tile(punit), range, ptile) {
acity = tile_city(ptile);
if (acity && pplayers_at_war(unit_owner(punit), city_owner(acity)) &&
(unit_list_size(ptile->units) == 0)) {
if (!map_is_known_and_seen(ptile, pplayer, V_MAIN)
&& ai_handicap(pplayer, H_FOG)) {
continue;
}
/* Prefer big cities on other continents */
val = city_size_get(acity)
+ (tile_continent(unit_tile(punit)) != tile_continent(ptile));
if (val > best) {
best = val;
best_tile = ptile;
}
}
} square_iterate_end;
/****************************************************************
...
*****************************************************************/
static void spy_steal_popup(Widget w, XtPointer client_data,
XtPointer call_data)
{
struct city *pvcity = game_city_by_number(diplomat_target_id);
struct player *pvictim = NULL;
if(pvcity)
pvictim = city_owner(pvcity);
/* it is concievable that pvcity will not be found, because something
has happened to the city during latency. Therefore we must initialize
pvictim to NULL and account for !pvictim in create_advances_list. -- Syela */
destroy_message_dialog(w);
diplomat_dialog = NULL;
if(!spy_tech_shell){
Position x, y;
Dimension width, height;
spy_tech_shell_is_modal=1;
create_advances_list(client.conn.playing, pvictim, spy_tech_shell_is_modal);
XtVaGetValues(toplevel, XtNwidth, &width, XtNheight, &height, NULL);
XtTranslateCoords(toplevel, (Position) width/10, (Position) height/10,
&x, &y);
XtVaSetValues(spy_tech_shell, XtNx, x, XtNy, y, NULL);
XtPopup(spy_tech_shell, XtGrabNone);
}
}
struct unit_list* get_units_present_in_city(struct city* pCity) {
if (city_owner(pCity) != client.conn.playing) {
return pCity->client.info_units_present;
} else {
return pCity->tile->units;
}
}
/**************************************************************************
Log city messages, they will appear like this
2: Polish Romenna(5,35) [s1 d106 u11 g1] must have Archers ...
**************************************************************************/
void real_city_log(const char *file, const char *function, int line,
enum log_level level, bool notify,
const struct city *pcity, const char *msg, ...)
{
char buffer[500];
char buffer2[500];
va_list ap;
char aibuf[500] = "\0";
CALL_PLR_AI_FUNC(log_fragment_city, city_owner(pcity), aibuf, sizeof(aibuf), pcity);
fc_snprintf(buffer, sizeof(buffer), "%s %s(%d,%d) [s%d] {%s} ",
nation_rule_name(nation_of_city(pcity)),
city_name(pcity),
TILE_XY(pcity->tile), city_size_get(pcity),
aibuf);
va_start(ap, msg);
fc_vsnprintf(buffer2, sizeof(buffer2), msg, ap);
va_end(ap);
cat_snprintf(buffer, sizeof(buffer), "%s", buffer2);
if (notify) {
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buffer);
}
do_log(file, function, line, FALSE, level, "%s", buffer);
}
/**************************************************************************
Assign a guard to a city.
**************************************************************************/
void aiguard_assign_guard_city(struct city *charge, struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
fc_assert_ret(charge != NULL);
fc_assert_ret(guard != NULL);
/*
* Usually, but not always, city_owner(charge) == unit_owner(guard).
*/
if (0 < guard_data->charge
&& guard_data->charge != charge->id) {
/* Remove previous assignment: */
aiguard_clear_charge(guard);
}
guard_data->charge = charge->id;
if (city_owner(charge) != unit_owner(guard)) {
/* Peculiar, but not always an error */
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "assigned foreign charge");
} else {
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "assigned charge");
}
CHECK_GUARD(guard);
}
/**************************************************************************
Check whether the assignment of a guard is still sane, and fix and problems.
It was once sane, but might have been destroyed or become an enemy since.
**************************************************************************/
void aiguard_update_charge(struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
const struct unit *charge_unit = game_unit_by_number(guard_data->charge);
const struct city *charge_city = game_city_by_number(guard_data->charge);
const struct player *guard_owner = unit_owner(guard);
const struct player *charge_owner = NULL;
fc_assert_ret(BODYGUARD_NONE <= guard_data->charge);
/* IDs always distinct */
fc_assert_ret(charge_unit == NULL || charge_city == NULL);
if (charge_unit) {
charge_owner = unit_owner(charge_unit);
} else if (charge_city) {
charge_owner = city_owner(charge_city);
}
if (!charge_unit && !charge_city && 0 < guard_data->charge) {
guard_data->charge = BODYGUARD_NONE;
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "charge was destroyed");
}
if (charge_owner && charge_owner != guard_owner) {
BODYGUARD_LOG(LOGLEVEL_BODYGUARD, guard, "charge transferred, dismiss");
aiguard_clear_charge(guard);
}
CHECK_GUARD(guard);
}
/**************************************************************************
Do sanity checks on a guard, reporting error messages to the log
if necessary.
Inconsistent references do not always indicate an error, because units
can change owners (for example, because of civil war) outside the control
the the AI code.
**************************************************************************/
void aiguard_check_guard(const struct unit *guard)
{
struct unit_ai *guard_data = def_ai_unit_data(guard);
const struct unit *charge_unit = game_unit_by_number(guard_data->charge);
const struct city *charge_city = game_city_by_number(guard_data->charge);
const struct player *guard_owner = unit_owner(guard);
const struct player *charge_owner = NULL;
struct unit_ai *charge_data = NULL;
fc_assert_ret(BODYGUARD_NONE <= guard_data->charge);
/* IDs always distinct */
fc_assert_ret(charge_unit == NULL || charge_city == NULL);
if (charge_unit) {
charge_owner = unit_owner(charge_unit);
charge_data = def_ai_unit_data(charge_unit);
} else if (charge_city) {
charge_owner = city_owner(charge_city);
}
if (charge_unit && charge_data->bodyguard != guard->id) {
BODYGUARD_LOG(LOG_DEBUG, guard, "inconsistent guard references");
} else if (!charge_unit && !charge_city && 0 < guard_data->charge) {
BODYGUARD_LOG(LOG_DEBUG, guard, "dangling guard reference");
}
if (charge_owner && pplayers_at_war(charge_owner, guard_owner)) {
/* Probably due to civil war */
BODYGUARD_LOG(LOG_DEBUG, guard, "enemy charge");
} else if (charge_owner && charge_owner != guard_owner) {
/* Probably sold a city with its supported units. */
BODYGUARD_LOG(LOG_DEBUG, guard, "foreign charge");
}
}
/****************************************************************
Selection from source
*****************************************************************/
static void src_selection_callback(GtkTreeSelection *selection, gpointer data)
{
struct worklist_data *ptr;
ptr = data;
/* update widget sensitivity. */
if (gtk_tree_selection_get_selected(selection, NULL, NULL)) {
if (can_client_issue_orders()
&& (!ptr->pcity || city_owner(ptr->pcity) == client.conn.playing)) {
/* if ptr->pcity is NULL, this is a global worklist */
gtk_widget_set_sensitive(ptr->change_cmd, TRUE);
gtk_widget_set_sensitive(ptr->prepend_cmd, TRUE);
gtk_widget_set_sensitive(ptr->append_cmd, TRUE);
} else {
gtk_widget_set_sensitive(ptr->change_cmd, FALSE);
gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE);
gtk_widget_set_sensitive(ptr->append_cmd, FALSE);
}
gtk_widget_set_sensitive(ptr->help_cmd, TRUE);
} else {
gtk_widget_set_sensitive(ptr->change_cmd, FALSE);
gtk_widget_set_sensitive(ptr->help_cmd, FALSE);
gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE);
gtk_widget_set_sensitive(ptr->append_cmd, FALSE);
}
}
/**************************************************************************
Calculate the benefit of building a base at the given tile.
The return value is the goodness of the tile after the base is built.
This should be compared to the goodness of the tile currently (see
city_tile_value(); note that this depends on the AI's weighting
values).
This function does not calculate the benefit of tile defense bonus and
many other typical base propoerties, just bonuses it gives to city.
**************************************************************************/
static int adv_calc_base(const struct city *pcity, const struct tile *ptile,
const struct base_type *pbase)
{
int goodness = -1;
fc_assert_ret_val(ptile != NULL, -1)
if (player_can_build_base(pbase, city_owner(pcity), ptile)) {
struct tile *vtile = tile_virtual_new(ptile);
tile_add_base(vtile, pbase);
extra_type_iterate(cextra) {
if (tile_has_extra(vtile, cextra)
&& !can_extras_coexist(base_extra_get(pbase), cextra)) {
tile_remove_extra(vtile, cextra);
}
} extra_type_iterate_end;
goodness = city_tile_value(pcity, vtile, 0, 0);
tile_virtual_destroy(vtile);
}
return goodness;
}
/**************************************************************************
Calculates the value of removing fallout at the given tile.
The return value is the goodness of the tile after the cleanup. This
should be compared to the goodness of the tile currently (see
city_tile_value(); note that this depends on the AI's weighting
values).
**************************************************************************/
static int adv_calc_fallout(const struct city *pcity,
const struct tile *ptile, int best)
{
int goodness;
struct tile *vtile;
bool polluted = FALSE;
fc_assert_ret_val(ptile != NULL, -1);
vtile = tile_virtual_new(ptile);
extra_type_by_cause_iterate(EC_FALLOUT, pextra) {
if (tile_has_extra(ptile, pextra)) {
tile_remove_extra(vtile, pextra);
polluted = TRUE;
}
} extra_type_by_cause_iterate_end;
if (!polluted) {
goodness = -1;
} else {
goodness = city_tile_value(pcity, vtile, 0, 0);
/* FIXME: need a better way to guarantee fallout is cleaned up. */
if (!city_owner(pcity)->ai_controlled) {
goodness = (goodness + best + 50) * 2;
}
}
tile_virtual_destroy(vtile);
return goodness;
}
/****************************************************************************
Returns the basic structure filled with current elements.
****************************************************************************/
void update_vision_site_from_city(struct vision_site *psite,
const struct city *pcity)
{
/* should be same identity and location */
psite->owner = city_owner(pcity);
psite->size = pcity->size;
sz_strlcpy(psite->name, city_name(pcity));
}
/*************************************************************************
What is type of the traderoute between two cities.
*************************************************************************/
enum trade_route_type cities_trade_route_type(const struct city *pcity1,
const struct city *pcity2)
{
if (city_owner(pcity1) != city_owner(pcity2)) {
if (city_tile(pcity1)->continent != city_tile(pcity2)->continent) {
return TRT_IN_IC;
} else {
return TRT_IN;
}
} else {
if (city_tile(pcity1)->continent != city_tile(pcity2)->continent) {
return TRT_NATIONAL_IC;
} else {
return TRT_NATIONAL;
}
}
return TRT_LAST;
}
/****************************************************************************
Returns the basic structure filled with initial elements.
****************************************************************************/
struct vision_site *create_vision_site_from_city(const struct city *pcity)
{
struct vision_site *psite =
create_vision_site(pcity->id, city_tile(pcity), city_owner(pcity));
psite->size = pcity->size;
sz_strlcpy(psite->name, city_name(pcity));
return psite;
}
/**************************************************************************
Calculate the benefit of building a road at the given tile.
The return value is the goodness of the tile after the road is built.
This should be compared to the goodness of the tile currently (see
city_tile_value(); note that this depends on the AI's weighting
values).
This function does not calculate the benefit of being able to quickly
move units (i.e., of connecting the civilization). See road_bonus() for
that calculation.
**************************************************************************/
static int adv_calc_road(const struct city *pcity, const struct tile *ptile,
const struct road_type *proad)
{
int goodness = -1;
fc_assert_ret_val(ptile != NULL, -1)
if (player_can_build_road(proad, city_owner(pcity), ptile)) {
struct tile *vtile = tile_virtual_new(ptile);
tile_add_road(vtile, proad);
goodness = city_tile_value(pcity, vtile, 0, 0);
tile_virtual_destroy(vtile);
}
return goodness;
}
/****************************************************************
Popup tech stealing dialog with list of possible techs
*****************************************************************/
static void spy_steal_popup(GtkWidget *w, gpointer data)
{
struct city *pvcity = game_city_by_number(diplomat_target_id);
struct player *pvictim = NULL;
if(pvcity)
pvictim = city_owner(pvcity);
/* it is concievable that pvcity will not be found, because something
has happened to the city during latency. Therefore we must initialize
pvictim to NULL and account for !pvictim in create_advances_list. -- Syela */
if(!spy_tech_shell){
create_advances_list(client.conn.playing, pvictim);
gtk_window_present(GTK_WINDOW(spy_tech_shell));
}
gtk_widget_destroy(diplomat_dialog);
}
/**************************************************************************
...
**************************************************************************/
static int spy_steal_popup(struct widget *pWidget)
{
struct city *pVcity = pWidget->data.city;
int id = MAX_ID - pWidget->ID;
struct player *pVictim = NULL;
struct CONTAINER *pCont;
struct widget *pBuf = NULL;
struct widget *pWindow;
SDL_String16 *pStr;
SDL_Surface *pSurf;
int max_col, max_row, col, i, count = 0;
SDL_Rect area;
popdown_diplomat_dialog();
if(pVcity)
{
pVictim = city_owner(pVcity);
}
if (pDiplomat_Dlg || !pVictim) {
return 1;
}
count = 0;
advance_index_iterate(A_FIRST, i) {
if (player_invention_reachable(client.conn.playing, i, FALSE)
&& TECH_KNOWN == player_invention_state(pVictim, i)
&& (TECH_UNKNOWN == player_invention_state(client.conn.playing, i)
|| TECH_PREREQS_KNOWN ==
player_invention_state(client.conn.playing, i))) {
count++;
}
} advance_index_iterate_end;
if(!count) {
/* if there is no known tech to steal then
send steal order at Spy's Discretion */
int target_id = pVcity->id;
request_diplomat_action(DIPLOMAT_STEAL, id, target_id, advance_count());
return -1;
}
pCont = fc_calloc(1, sizeof(struct CONTAINER));
pCont->id0 = pVcity->id;
pCont->id1 = id;/* spy id */
pDiplomat_Dlg = fc_calloc(1, sizeof(struct diplomat_dialog));
pDiplomat_Dlg->diplomat_id = id;
pDiplomat_Dlg->diplomat_target_id = pVcity->id;
pDiplomat_Dlg->pdialog = fc_calloc(1, sizeof(struct ADVANCED_DLG));
pStr = create_str16_from_char(_("Select Advance to Steal"), adj_font(12));
pStr->style |= TTF_STYLE_BOLD;
pWindow = create_window_skeleton(NULL, pStr, 0);
pWindow->action = spy_steal_dlg_window_callback;
set_wstate(pWindow , FC_WS_NORMAL);
add_to_gui_list(ID_DIPLOMAT_DLG_WINDOW, pWindow);
pDiplomat_Dlg->pdialog->pEndWidgetList = pWindow;
area = pWindow->area;
area.w = MAX(area.w, adj_size(8));
/* ------------------ */
/* exit button */
pBuf = create_themeicon(pTheme->Small_CANCEL_Icon, pWindow->dst,
WF_WIDGET_HAS_INFO_LABEL | WF_RESTORE_BACKGROUND);
pBuf->info_label = create_str16_from_char(_("Close Dialog (Esc)"),
adj_font(12));
area.w += pBuf->size.w + adj_size(10);
pBuf->action = exit_spy_steal_dlg_callback;
set_wstate(pBuf, FC_WS_NORMAL);
pBuf->key = SDLK_ESCAPE;
add_to_gui_list(ID_TERRAIN_ADV_DLG_EXIT_BUTTON, pBuf);
/* ------------------------- */
count++; /* count + at Spy's Discretion */
/* max col - 104 is steal tech widget width */
max_col = (Main.screen->w - (pWindow->size.w - pWindow->area.w) - adj_size(2)) / adj_size(104);
/* max row - 204 is steal tech widget height */
max_row = (Main.screen->h - (pWindow->size.h - pWindow->area.h)) / adj_size(204);
/* make space on screen for scrollbar */
if (max_col * max_row < count) {
max_col--;
}
if (count < max_col + 1) {
col = count;
} else {
if (count < max_col + adj_size(3)) {
col = max_col - adj_size(2);
} else {
if (count < max_col + adj_size(5)) {
col = max_col - 1;
} else {
col = max_col;
}
}
}
pStr = create_string16(NULL, 0, adj_font(10));
pStr->style |= (TTF_STYLE_BOLD | SF_CENTER);
count = 0;
advance_index_iterate(A_FIRST, i) {
if (player_invention_reachable(client.conn.playing, i, FALSE)
&& TECH_KNOWN == player_invention_state(pVictim, i)
&& (TECH_UNKNOWN == player_invention_state(client.conn.playing, i)
|| TECH_PREREQS_KNOWN ==
player_invention_state(client.conn.playing, i))) {
count++;
copy_chars_to_string16(pStr, advance_name_translation(advance_by_number(i)));
pSurf = create_sellect_tech_icon(pStr, i, FULL_MODE);
pBuf = create_icon2(pSurf, pWindow->dst,
WF_FREE_THEME | WF_RESTORE_BACKGROUND);
set_wstate(pBuf, FC_WS_NORMAL);
pBuf->action = spy_steal_callback;
pBuf->data.cont = pCont;
add_to_gui_list(MAX_ID - i, pBuf);
if (count > (col * max_row)) {
set_wflag(pBuf, WF_HIDDEN);
}
}
} advance_index_iterate_end;
/* get spy tech */
i = advance_number(unit_type(game_unit_by_number(id))->require_advance);
copy_chars_to_string16(pStr, _("At Spy's Discretion"));
pSurf = create_sellect_tech_icon(pStr, i, FULL_MODE);
pBuf = create_icon2(pSurf, pWindow->dst,
(WF_FREE_THEME | WF_RESTORE_BACKGROUND| WF_FREE_DATA));
set_wstate(pBuf, FC_WS_NORMAL);
pBuf->action = spy_steal_callback;
pBuf->data.cont = pCont;
add_to_gui_list(MAX_ID - advance_count(), pBuf);
count++;
/* --------------------------------------------------------- */
FREESTRING16(pStr);
pDiplomat_Dlg->pdialog->pBeginWidgetList = pBuf;
pDiplomat_Dlg->pdialog->pBeginActiveWidgetList = pDiplomat_Dlg->pdialog->pBeginWidgetList;
pDiplomat_Dlg->pdialog->pEndActiveWidgetList = pDiplomat_Dlg->pdialog->pEndWidgetList->prev->prev;
/* -------------------------------------------------------------- */
i = 0;
if (count > col) {
count = (count + (col - 1)) / col;
if (count > max_row) {
pDiplomat_Dlg->pdialog->pActiveWidgetList = pDiplomat_Dlg->pdialog->pEndActiveWidgetList;
count = max_row;
i = create_vertical_scrollbar(pDiplomat_Dlg->pdialog, col, count, TRUE, TRUE);
}
} else {
count = 1;
}
area.w = MAX(area.w, (col * pBuf->size.w + adj_size(2) + i));
area.h = count * pBuf->size.h + adj_size(2);
/* alloca window theme and win background buffer */
pSurf = theme_get_background(theme, BACKGROUND_SPYSTEALDLG);
if (resize_window(pWindow, pSurf, NULL,
(pWindow->size.w - pWindow->area.w) + area.w,
(pWindow->size.h - pWindow->area.h) + area.h))
{
FREESURFACE(pSurf);
}
area = pWindow->area;
widget_set_position(pWindow,
(Main.screen->w - pWindow->size.w) / 2,
(Main.screen->h - pWindow->size.h) / 2);
/* exit button */
pBuf = pWindow->prev;
pBuf->size.x = area.x + area.w - pBuf->size.w - 1;
pBuf->size.y = pWindow->size.y + adj_size(2);
setup_vertical_widgets_position(col, area.x + 1,
area.y, 0, 0,
pDiplomat_Dlg->pdialog->pBeginActiveWidgetList,
pDiplomat_Dlg->pdialog->pEndActiveWidgetList);
if(pDiplomat_Dlg->pdialog->pScroll) {
setup_vertical_scrollbar_area(pDiplomat_Dlg->pdialog->pScroll,
area.x + area.w, area.y,
area.h, TRUE);
}
redraw_group(pDiplomat_Dlg->pdialog->pBeginWidgetList, pWindow, FALSE);
widget_mark_dirty(pWindow);
return -1;
}
/**************************************************************************
Is an evalutaion of the requirement accurate when pow_player evaluates
it?
Note: Assumed to use pow_player's data.
TODO: Move the data to a data file. That will
- let non programmers help complete it and/or fix what is wrong
- let clients not written in C use the data
**************************************************************************/
static bool is_req_knowable(const struct player *pow_player,
const struct player *target_player,
const struct player *other_player,
const struct city *target_city,
const struct impr_type *target_building,
const struct tile *target_tile,
const struct unit_type *target_unittype,
const struct output_type *target_output,
const struct specialist *target_specialist,
const struct requirement *req)
{
fc_assert_ret_val_msg(NULL != pow_player, false, "No point of view");
if ((req->source.kind == VUT_UTFLAG || req->source.kind == VUT_UTYPE)
&& target_unittype != NULL) {
return TRUE;
}
if (req->source.kind == VUT_DIPLREL
&& pow_player == target_player
&& (req->range == REQ_RANGE_LOCAL
|| req->range == REQ_RANGE_PLAYER)) {
return TRUE;
}
if (req->source.kind == VUT_MINSIZE && target_city != NULL) {
enum known_type vision =
tile_get_known(city_tile(target_city), pow_player);
if (vision == TILE_KNOWN_SEEN
|| city_owner(target_city) == pow_player) {
return TRUE;
}
}
if (req->source.kind == VUT_CITYTILE
&& req->range == REQ_RANGE_LOCAL) {
enum known_type vision =
tile_get_known(target_tile, pow_player);
if (vision == TILE_KNOWN_SEEN
|| (target_city && city_owner(target_city) == pow_player)) {
return TRUE;
}
}
if (req->source.kind == VUT_NATION) {
return TRUE;
}
if (req->source.kind == VUT_ADVANCE || req->source.kind == VUT_TECHFLAG) {
if (req->range == REQ_RANGE_PLAYER
&& (pow_player == target_player
|| player_has_embassy(pow_player, target_player))) {
return TRUE;
}
}
if (req->source.kind == VUT_GOVERNMENT) {
if (req->range == REQ_RANGE_PLAYER
&& (pow_player == target_player
|| could_intel_with_player(pow_player, target_player))) {
return TRUE;
}
}
/* Uncertain or no support added yet. */
return FALSE;
}
/**************************************************************************
Main handler for key presses
**************************************************************************/
static Uint16 main_key_down_handler(SDL_keysym Key, void *pData)
{
static struct widget *pWidget;
if ((pWidget = find_next_widget_for_key(NULL, Key)) != NULL) {
return widget_pressed_action(pWidget);
} else {
if (Key.sym == SDLK_TAB) {
/* input */
popup_input_line();
} else {
if (map_event_handler(Key)
&& C_S_RUNNING == client_state()) {
switch (Key.sym) {
case SDLK_RETURN:
case SDLK_KP_ENTER:
if (LSHIFT || RSHIFT) {
disable_focus_animation();
key_end_turn();
} else {
struct unit *pUnit;
struct city *pCity;
if (NULL != (pUnit = head_of_units_in_focus()) &&
(pCity = tile_city(unit_tile(pUnit))) != NULL &&
city_owner(pCity) == client.conn.playing) {
popup_city_dialog(pCity);
}
}
return ID_ERROR;
case SDLK_F2:
units_report_dialog_popup(FALSE);
return ID_ERROR;
case SDLK_F4:
city_report_dialog_popup(FALSE);
return ID_ERROR;
case SDLK_F7:
send_report_request(REPORT_WONDERS_OF_THE_WORLD);
return ID_ERROR;
case SDLK_F8:
send_report_request(REPORT_TOP_5_CITIES);
return ID_ERROR;
case SDLK_F9:
if (meswin_dialog_is_open()) {
meswin_dialog_popdown();
} else {
meswin_dialog_popup(TRUE);
}
flush_dirty();
return ID_ERROR;
case SDLK_F11:
send_report_request(REPORT_DEMOGRAPHIC);
return ID_ERROR;
case SDLK_F12:
popup_spaceship_dialog(client.conn.playing);
return ID_ERROR;
default:
return ID_ERROR;
}
}
}
}
return ID_ERROR;
}
void citizens_update(struct city *pcity)
{
int delta;
fc_assert_ret(pcity);
if (pcity->server.debug) {
/* before */
citizens_print(pcity);
}
if (game.info.citizen_nationality != TRUE) {
return;
}
if (pcity->nationality == NULL) {
/* If nationalities are not set (virtual cities) do nothing. */
return;
}
delta = city_size_get(pcity) - citizens_count(pcity);
if (delta == 0) {
/* No change of the city size */
return;
}
if (delta > 0) {
/* Add new citizens with the nationality of the current owner. */
citizens_nation_add(pcity, city_owner(pcity)->slot, delta);
log_citizens_add(pcity, delta, city_owner(pcity));
} else {
/* Removed citizens. */
struct player_slot *city_nations[MAX_NUM_PLAYER_SLOTS];
int count = 0;
/* Create a list of foreign nationalities. */
citizens_foreign_iterate(pcity, pslot, nationality) {
city_nations[count] = pslot;
count++;
} citizens_foreign_iterate_end;
/* First remove from foreign nationalities. */
while (count > 0 && delta < 0) {
int select = fc_rand(count);
struct player_slot *pslot = city_nations[select];
struct player *pplayer = player_slot_get_player(pslot);
citizens nationality = citizens_nation_get(pcity, pslot);
fc_assert_ret(nationality != 0);
fc_assert_ret(pplayer != NULL);
if (nationality == 1) {
/* Remove one citizen. */
delta++;
citizens_nation_set(pcity, pslot, 0);
/* Remove this nation from the list of nationalities. */
if (select != count) {
city_nations[select] = city_nations[count - 1];
}
count--;
log_citizens_add(pcity, -1, pplayer);
} else {
/* Get the minimal reduction = the maximum value of two negative
* numbers. */
int diff = MAX(delta, - nationality / 2);
delta -= diff;
citizens_nation_add(pcity, pslot, diff);
log_citizens_add(pcity, diff, pplayer);
}
}
if (delta < 0) {
/* Now take the remaining citizens loss from the nation of the owner. */
citizens_nation_add(pcity, city_owner(pcity)->slot, delta);
log_citizens_add(pcity, delta, city_owner(pcity));
}
}
/**************************************************************************
Calculate the benefit of irrigating the given tile.
The return value is the goodness of the tile after the irrigation. This
should be compared to the goodness of the tile currently (see
city_tile_value(); note that this depends on the AI's weighting
values).
**************************************************************************/
static int adv_calc_irrigate(const struct city *pcity,
const struct tile *ptile)
{
int goodness;
struct terrain *old_terrain, *new_terrain;
fc_assert_ret_val(ptile != NULL, -1)
old_terrain = tile_terrain(ptile);
new_terrain = old_terrain->irrigation_result;
if (new_terrain != old_terrain && new_terrain != T_NONE) {
struct tile *vtile;
if (tile_city(ptile) && terrain_has_flag(new_terrain, TER_NO_CITIES)) {
/* Not a valid activity. */
return -1;
}
/* Irrigation would change the terrain type, clearing conflicting
* extras in the process. Calculate the benefit of doing so. */
vtile = tile_virtual_new(ptile);
tile_change_terrain(vtile, new_terrain);
goodness = city_tile_value(pcity, vtile, 0, 0);
tile_virtual_destroy(vtile);
return goodness;
} else if (old_terrain == new_terrain) {
struct extra_type *pextra = next_extra_for_tile(ptile, EC_IRRIGATION,
city_owner(pcity), NULL);
if (pextra != NULL) {
struct tile *vtile = tile_virtual_new(ptile);
/* Try to add extra, and to remove conflicting ones. */
if (tile_extra_apply(vtile, pextra)) {
struct extra_type *pextra2 = next_extra_for_tile(vtile, EC_IRRIGATION,
city_owner(pcity), NULL);
goodness = city_tile_value(pcity, vtile, 0, 0);
if (pextra2 != NULL) {
struct tile *vtile2 = tile_virtual_new(vtile);
/* If the player can further irrigate to make farmland, consider the
* potentially greater benefit. Note the hack: autosettler ordinarily
* discounts benefits by the time it takes to make them; farmland takes
* twice as long, so make it look half as good. */
if (tile_extra_apply(vtile2, pextra2)) {
int second_goodness = city_tile_value(pcity, vtile2, 0, 0);
int oldv = city_tile_value(pcity, ptile, 0, 0);
second_goodness = oldv + (second_goodness - oldv) / 2;
if (second_goodness > goodness) {
goodness = second_goodness;
}
}
tile_virtual_destroy(vtile2);
}
tile_virtual_destroy(vtile);
return goodness;
}
}
/* Cannot build irrigation extra */
return -1;
} else {
return -1;
}
}
/****************************************************************
Refresh worklist info
*****************************************************************/
void refresh_worklist(GtkWidget *editor)
{
struct worklist_data *ptr;
const struct global_worklist *pgwl = NULL;
struct worklist queue;
struct universal targets[MAX_NUM_PRODUCTION_TARGETS];
int i, targets_used;
struct item items[MAX_NUM_PRODUCTION_TARGETS];
bool selected;
gint id;
GtkTreeIter it;
GtkTreePath *path;
GtkTreeModel *model;
gboolean exists;
ptr = g_object_get_data(G_OBJECT(editor), "data");
if (!ptr->pcity
&& !(pgwl = global_worklist_by_id(ptr->global_worklist_id))) {
}
/* refresh source tasks. */
if (gtk_tree_selection_get_selected(ptr->src_selection, NULL, &it)) {
gtk_tree_model_get(GTK_TREE_MODEL(ptr->src), &it, 0, &id, -1);
selected = TRUE;
} else {
selected = FALSE;
}
gtk_list_store_clear(ptr->src);
targets_used = collect_eventually_buildable_targets(targets, ptr->pcity,
ptr->future);
name_and_sort_items(targets, targets_used, items, FALSE, ptr->pcity);
path = NULL;
for (i = 0; i < targets_used; i++) {
gtk_list_store_append(ptr->src, &it);
gtk_list_store_set(ptr->src, &it, 0, (gint) cid_encode(items[i].item), -1);
if (selected && cid_encode(items[i].item) == id) {
path = gtk_tree_model_get_path(GTK_TREE_MODEL(ptr->src), &it);
}
}
if (path) {
gtk_tree_view_set_cursor(GTK_TREE_VIEW(ptr->src_view), path, NULL, FALSE);
gtk_tree_path_free(path);
}
/* refresh target worklist. */
model = GTK_TREE_MODEL(ptr->dst);
exists = gtk_tree_model_get_iter_first(model, &it);
/* dance around worklist braindamage. */
if (ptr->pcity) {
city_get_queue(ptr->pcity, &queue);
} else {
fc_assert(NULL != pgwl);
worklist_copy(&queue, global_worklist_get(pgwl));
}
for (i = 0; i < worklist_length(&queue); i++) {
struct universal target = queue.entries[i];
if (!exists) {
gtk_list_store_append(ptr->dst, &it);
}
gtk_list_store_set(ptr->dst, &it, 0, (gint) cid_encode(target), -1);
if (exists) {
exists = gtk_tree_model_iter_next(model, &it);
}
}
if (exists) {
GtkTreeIter it_next;
bool more;
do {
it_next = it;
more = gtk_tree_model_iter_next(model, &it_next);
gtk_list_store_remove(ptr->dst, &it);
it = it_next;
} while (more);
}
/* update widget sensitivity. */
if (ptr->pcity) {
if ((can_client_issue_orders() &&
city_owner(ptr->pcity) == client.conn.playing)) {
gtk_widget_set_sensitive(ptr->add_cmd, TRUE);
gtk_widget_set_sensitive(ptr->dst_view, TRUE);
} else {
gtk_widget_set_sensitive(ptr->add_cmd, FALSE);
gtk_widget_set_sensitive(ptr->dst_view, FALSE);
}
} else {
gtk_widget_set_sensitive(ptr->add_cmd, TRUE);
gtk_widget_set_sensitive(ptr->dst_view, TRUE);
}
}