Freeciv

{

int providers = 0;

if (get_specialist_output(pcity, i, O_LUXURY) >= game.info.happy_cost) {

providers += pcity->specialists[i];

}

return providers;

}

case VUT_SPECIALIST:

if (preq->present) {

requirement_vector_iterate(&(preq->source.value.specialist)->reqs,

sreq) {

if (!dai_can_requirement_be_met_in_city(sreq, pplayer, pcity)) {

return FALSE;

}

} requirement_vector_iterate_end;

case VUT_NATIONALITY:

/* Crude, but the right answer needs to consider civil wars. */

}

if (!martial_need) {

if (pcity->specialists[sp] > 0

&& get_specialist_output(pcity, sp, O_LUXURY) > 0) {

martial_need = TRUE;

break;

}

}

if (martial_need

int entertainers = 0;

bool enough = FALSE;

if (get_specialist_output(pcity, sp, O_LUXURY) > 0) {

entertainers += pcity->specialists[sp];

}

martless_unhappy += entertainers; /* We want to use martial law instead

* of entertainers. */

T(disorder);

T(happy);

T(specialists[sp]);

output_type_iterate(ot) {

T(surplus[ot]);

} city_tile_iterate_skip_free_worked_end;

/* Change the excess non-default specialists to default. */

int i;

if (sp == DEFAULT_SPECIALIST) {

first_request_id = last_request_id;

}

}

/* now all surplus people are DEFAULT_SPECIALIST */

/* Set all specialists except DEFAULT_SPECIALIST (all the unchanged

* ones remain as DEFAULT_SPECIALIST). */

int i;

if (sp == DEFAULT_SPECIALIST) {

first_request_id = last_request_id;

}

}

if (last_request_id == 0 || ALWAYS_APPLY_AT_SERVER) {

/*

should be the happiness index from FEELING_BASE to FEELING_FINAL.

"categories" should be an array large enough to hold all citizens

(use MAX_CITY_SIZE to be on the safe side).

Return number of categories filled (presumed equal to city size).

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

int get_city_citizen_types(struct city *pcity, enum citizen_feeling idx,

categories[i] = CITIZEN_ANGRY;

}

for (n = 0; n < pcity->specialists[sp]; n++, i++) {

categories[i] = CITIZEN_SPECIALIST + sp;

}

if (city_size_get(pcity) != i) {

log_error("get_city_citizen_types() %d citizens "

return i;

}

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

Rotate the given specialist citizen to the next type of citizen.

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

/* Loop through all specialists in order until we find a usable one

* (or run out of choices). */

to = from;

do {

} while (to != from && !city_can_use_specialist(pcity, to));

if (from != to) {

int get_city_citizen_types(struct city *pcity, enum citizen_feeling index,

enum citizen_category *categories);

void city_rotate_specialist(struct city *pcity, int citizen_index);

void activate_all_units(struct tile *ptile);

int citizen_bar_width, citizen_bar_height;

struct city *pcity = pdialog->pcity;

int num_citizens = get_city_citizen_types(pcity, FEELING_FINAL, categories);

cairo_t *cr;

/* If there is not enough space we stack the icons. We draw from left to */

/* right. width is how far we go to the right for each drawn pixmap. The */

/* last icon is always drawn in full, and so has reserved */

struct city *pcity = pdialog->pcity;

int granaryturns;

int non_workers = city_specialists(pcity);

/* fill the buffers with the necessary info */

fc_snprintf(buf[INFO_SIZE], sizeof(buf[INFO_SIZE]), "%3d (%3d)",

pcity->size, non_workers);

} else {

int citizen_bar_width, citizen_bar_height;

struct city *pcity = pdialog->pcity;

int num_citizens = get_city_citizen_types(pcity, FEELING_FINAL, categories);

cairo_t *cr;

/* If there is not enough space we stack the icons. We draw from left to */

/* right. width is how far we go to the right for each drawn pixmap. The */

/* last icon is always drawn in full, and so has reserved */

struct city *pcity = pdialog->pcity;

int granaryturns;

int non_workers = city_specialists(pcity);

/* fill the buffers with the necessary info */

fc_snprintf(buf[INFO_SIZE], sizeof(buf[INFO_SIZE]), "%3d (%3d)",

pcity->size, non_workers);

} else {

int citizen_bar_width, citizen_bar_height;

struct city *pcity = pdialog->pcity;

int num_citizens = get_city_citizen_types(pcity, FEELING_FINAL, categories);

cairo_t *cr;

/* If there is not enough space we stack the icons. We draw from left to */

/* right. width is how far we go to the right for each drawn pixmap. The */

/* last icon is always drawn in full, and so has reserved */

struct city *pcity = pdialog->pcity;

int granaryturns;

int non_workers = city_specialists(pcity);

/* fill the buffers with the necessary info */

fc_snprintf(buf[INFO_SIZE], sizeof(buf[INFO_SIZE]), "%3d (%3d)",

pcity->size, non_workers);

} else {

QPainter p;

QPixmap *pix;

int num_citizens = get_city_citizen_types(dlgcity, FEELING_FINAL, categories);

int w = tileset_small_sprite_width(tileset) / gui()->map_scale;

int h = tileset_small_sprite_height(tileset) / gui()->map_scale;

i = 1 + (num_citizens * 5 / 200);

w = w / i;

QRect source_rect(0, 0, w, h);

char buf_info[NUM_INFO_FIELDS][512];

char buf_tooltip[NUM_INFO_FIELDS][512];

int granaryturns;

for (int i = 0; i < NUM_INFO_FIELDS; i++) {

buf_info[i][0] = '\0';

// Fill the buffers with the necessary info

spec = city_specialists(dlgcity);

fc_snprintf(buf_info[INFO_CITIZEN], sizeof(buf_info[INFO_CITIZEN]),

"%3d (%4d)", dlgcity->size, spec);

fc_snprintf(buf_info[INFO_FOOD], sizeof(buf_info[INFO_FOOD]), "%3d (%+4d)",

dlgcity->prod[O_FOOD], dlgcity->surplus[O_FOOD]);

fc_snprintf(buf_info[INFO_SHIELD], sizeof(buf_info[INFO_SHIELD]),

/* count != 0 */

/* ==================================================== */

count = (pcity->feel[CITIZEN_HAPPY][FEELING_FINAL] + pcity->feel[CITIZEN_CONTENT][FEELING_FINAL]

+ pcity->feel[CITIZEN_UNHAPPY][FEELING_FINAL] + pcity->feel[CITIZEN_ANGRY][FEELING_FINAL]

buf = get_citizen_surface(CITIZEN_HAPPY, 0);

if (count > 13) {

pcity_dlg->spec_area.y = pwindow->dst->dest_rect.y + dest.y;

pcity_dlg->spec_area.w = count * step;

pcity_dlg->spec_area.h = buf->h;

if (pcity->feel[CITIZEN_HAPPY][FEELING_FINAL]) {

for (i = 0; i < pcity->feel[CITIZEN_HAPPY][FEELING_FINAL]; i++) {

buf = adj_surf(get_citizen_surface(CITIZEN_SPECIALIST + spe, i));

for (i = 0; i < pcity->specialists[spe]; i++) {

alphablit(buf, NULL, pwindow->dst->surface, &dest, 255);

dest.x += step;

}

/* count != 0 */

/* ==================================================== */

count = (pcity->feel[CITIZEN_HAPPY][FEELING_FINAL] + pcity->feel[CITIZEN_CONTENT][FEELING_FINAL]

+ pcity->feel[CITIZEN_UNHAPPY][FEELING_FINAL] + pcity->feel[CITIZEN_ANGRY][FEELING_FINAL]

buf = get_citizen_surface(CITIZEN_HAPPY, 0);

cat_snprintf(buf, bufsz, "%s\n\n", _(text));

} strvec_iterate_end;

}

/* Requirements for this specialist. */

requirement_vector_iterate(&pspec->reqs, preq) {

}

specialist_type_iterate(sp) {

pcity->specialists[sp] = packet->specialists[sp];

} specialist_type_iterate_end;

if (city_size_get(pcity) != packet->size) {

fc_assert_ret(0 == soln->idle);

/* Clear all specialists, and remove all workers from fields (except

city_map_iterate(city_radius_sq, cindex, x, y) {

if (is_free_worked_index(cindex)) {

/* for each specialist type, create a tile_type that has as production

* the bonus for the specialist (if the city is allowed to use it) */

if (city_can_use_specialist(pcity, i)) {

type.spec = i;

output_type_iterate(output) {

tile_type_lattice_add(lattice, &type, 0);

}

}

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

{

int count = 0;

count += result->specialists[spec];

return count;

}

}

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

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

citizens city_specialists(const struct city *pcity)

{

citizens count = 0;

fc_assert_ret_val(MAX_CITY_SIZE - count > pcity->specialists[sp], 0);

count += pcity->specialists[sp];

return count;

}

int best = DEFAULT_SPECIALIST;

int val = get_specialist_output(pcity, best, otype);

if (!pcity || city_can_use_specialist(pcity, i)) {

int val2 = get_specialist_output(pcity, i, otype);

val = val2;

}

}

return best;

}

void city_size_set(struct city *pcity, citizens size);

citizens city_specialists(const struct city *pcity);

citizens player_content_citizens(const struct player *pplayer);

citizens player_angry_citizens(const struct player *pplayer);

UINT16 num_city_styles;

UINT16 terrain_count;

UINT16 num_specialist_types;

UINT16 num_nation_groups;

UINT16 num_nation_sets;

return game.control.num_specialist_types;

}

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

Return the specialist index.

return name_translation_get(&sp->abbreviation);

}

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

Return a string containing all the specialist abbreviations, for instance

"E/S/T".

/* General specialist accessor functions. */

Specialist_type_id specialist_count(void);

Specialist_type_id specialist_index(const struct specialist *sp);

Specialist_type_id specialist_number(const struct specialist *sp);

const char *specialist_plural_translation(const struct specialist *sp);

const char *specialist_abbreviation_translation(const struct specialist *sp);

/* Ancillary routines */

const char *specialists_abbreviation_string(void);

const char *specialists_string(const citizens *specialist_list);

} \

}

#define specialist_type_re_active_iterate(_p) \

specialist_type_iterate(_p##_) { \

struct specialist *_p = specialist_by_number(_p##_); \

return;

}

|| !city_can_use_specialist(pcity, to)

|| pcity->specialists[from] == 0) {

/* This could easily just be due to clicking faster on the specialist

city_map_update_worker(pcity, ptile);

if (pcity->specialists[i] > 0) {

pcity->specialists[i]--;

break;

}

city_refresh(pcity);

sanity_check_city(pcity);

bool dipl_invest)

{

int i;

fc_assert(!pcity->server.needs_arrange);

packet->specialists_size = specialist_count();

specialist_type_iterate(sp) {

packet->specialists[sp] = pcity->specialists[sp];

} specialist_type_iterate_end;

/* The nationality of the citizens. */

}

} city_tile_iterate_skip_free_worked_end;

pcity->specialists[sp] = cmr->specialists[sp];

}

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

fc_assert_ret_val(0 < change, 0);

citizens fix = MIN(want, pcity->specialists[sp]);

pcity->specialists[sp] -= fix;

want -= fix;

return change - want;

}

#define RESOURCE_SECTION_PREFIX "resource_"

#define GOODS_SECTION_PREFIX "goods_"

#define SPECIALIST_SECTION_PREFIX "specialist_"

#define TERRAIN_SECTION_PREFIX "terrain_"

#define UNIT_CLASS_SECTION_PREFIX "unitclass_"

#define UNIT_SECTION_PREFIX "unit_"

const char *path,

struct veteran_system **vsystem, char *err,

size_t err_len);

char *script_buffer = NULL;

char *parser_buffer = NULL;

filename));

}

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

Load cities.ruleset file

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

struct rscompat_info *compat)

{

const char *filename = secfile_name(file);

bool ok = TRUE;

if (!rscompat_check_cap_and_version(file, filename, compat)) {

return FALSE;

/* Specialist options */

sec = secfile_sections_by_name_prefix(file, SPECIALIST_SECTION_PREFIX);

ok = FALSE;

}

section_list_iterate(sec, psection) {

struct specialist *s = specialist_by_number(i);

break;

}

if (requirement_vector_size(&s->reqs) == 0 && DEFAULT_SPECIALIST == -1) {

DEFAULT_SPECIALIST = i;

} section_list_iterate_end;

}

}

section_list_destroy(sec);

sec = NULL;

if (ok) {

/* City Parameters */

city_size_set(pcity, size);

for (i = 0; i < loading->specialist.size; i++) {

sg_warn_ret_val(secfile_lookup_int(loading->file, &value, "%s.nspe%d",

citystr, i),

FALSE, "%s", secfile_error());

}

partner = secfile_lookup_int_default(loading->file, 0, "%s.traderoute0", citystr);

+ pplayer->score.unhappy

+ pplayer->score.angry);

count += pplayer->score.specialists[sp];

return count;

}

struct specialist *s = specialist_by_number(sp);

char path[512];

save_name_translation(sfile, &(s->name), path);