63#define BULLET Q_("?bullet:*")
65#define BULLET_SPACE Q_("?bullet:* ")
68#define CATLSTR(_b, _s, _t, ...) cat_snprintf(_b, _s, _t, ## __VA_ARGS__)
72 "(Any)",
"(Text)",
"Units",
"Improvements",
"Wonders",
73 "Techs",
"Terrain",
"Extras",
"Goods",
"Specialists",
"Governments",
74 "Ruleset",
"Tileset",
"Musicset",
"Nations",
"Multipliers",
"Counters",
NULL
77#define SPECLIST_TAG help
78#define SPECLIST_TYPE struct help_item
81#define help_list_iterate(helplist, phelp) \
82 TYPED_LIST_ITERATE(struct help_item, helplist, phelp)
83#define help_list_iterate_end LIST_ITERATE_END
161 if (veteran->
levels == 1) {
181 _(
"Veteran level Power factor Move bonus\n"));
184 _(
"--------------------------------------------"));
194 "\n%s%*s %4d%% %12s",
214 if (0 ==
strcmp(
name,
"TerrainAlterations")) {
221 _(
"Terrain Cultivate Plant Transform\n"));
223 "----------------------------------------------------------------\n");
227 const char *
terrain, *cultivate_result,
228 *plant_result,*transform_result;
233 "%d", pterrain->cultivate_time);
235 "%d", pterrain->plant_time);
236 fc_snprintf(transform_time,
sizeof(transform_time),
237 "%d", pterrain->transform_time);
240 (pterrain->cultivate_result ==
T_NONE
245 (pterrain->plant_result ==
T_NONE
250 (pterrain->transform_result == pterrain
251 || pterrain->transform_result ==
T_NONE
262 "%s%*s %3s %s%*s %3s %s%*s %3s %s\n",
268 (pterrain->plant_result ==
T_NONE) ?
"-" : plant_time,
271 (pterrain->transform_result ==
T_NONE) ?
"-" : transform_time,
288 if (pillage_time != 0 && pterrain->pillage_time != 0) {
289 if (pillage_time < 0) {
290 pillage_time = pterrain->pillage_time;
292 if (pillage_time != pterrain->pillage_time) {
305 int time = -1, factor = -1;
308 if (pextra->removal_time == 0) {
310 factor = pextra->removal_time_factor;
311 }
else if (factor != pextra->removal_time_factor) {
316 time = pextra->removal_time;
317 }
else if (time != pextra->removal_time) {
334 if (time > 0 && factor > 0 && time !=
clean_time * factor) {
336 }
else if (time >= 0) {
338 }
else if (factor >= 0) {
347 int time = -1, factor = -1;
350 if (pextra->removal_time == 0) {
352 factor = pextra->removal_time_factor;
353 }
else if (factor != pextra->removal_time_factor) {
358 time = pextra->removal_time;
359 }
else if (time != pextra->removal_time) {
371 }
else if (pillage_time != 0) {
374 if (time > 0 && factor > 0 && time != pillage_time * factor) {
376 }
else if (time >= 0) {
378 }
else if (factor >= 0) {
379 pillage_time = pillage_time * factor;
390 if (pextra->buildable && pextra->build_time > 0) {
397 if (pextra->buildable && pextra->build_time > 0) {
408 _(
"Time taken for the following activities is independent of "
414 _(
"Activity Time\n"));
416 "---------------------------");
421 if (pillage_time > 0) {
423 _(
"\nPillage %3d"), pillage_time);
427 if (pextra->buildable && pextra->build_time > 0) {
440 if (pextra->buildable && pextra->build_time > 0) {
454 }
else if (0 ==
strcmp(
name,
"VeteranLevels")) {
456 _(
"In this ruleset, the following veteran levels are defined:"),
457 _(
"This ruleset has no default veteran levels defined."));
458 }
else if (0 ==
strcmp(
name,
"FreecivVersion")) {
469 }
else if (0 ==
strcmp(
name,
"DefaultMetaserver")) {
488 const char *
const *
strs,
572 char *
buf,
size_t bufsz,
const char *prefix)
577 static const char *
const govstrs[] = {
579 N_(
"?gov:Allows %s (with %s but no %s)."),
581 N_(
"?gov:Allows %s (with %s)."),
583 N_(
"?gov:Allows %s (absent %s)."),
585 N_(
"?gov:Allows %s."),
587 N_(
"?gov:Prevents %s.")
596 static const char *
const imprstrs[] = {
598 N_(
"?improvement:Allows %s (with %s but no %s)."),
600 N_(
"?improvement:Allows %s (with %s)."),
602 N_(
"?improvement:Allows %s (absent %s)."),
604 N_(
"?improvement:Allows %s."),
606 N_(
"?improvement:Prevents %s.")
615 static const char *
const utstrs[] = {
617 N_(
"?unittype:Allows %s (with %s but no %s)."),
619 N_(
"?unittype:Allows %s (with %s)."),
621 N_(
"?unittype:Allows %s (absent %s)."),
623 N_(
"?unittype:Allows %s."),
625 N_(
"?unittype:Prevents %s.")
633 static const char *
const estrs[] = {
635 N_(
"?extra:Allows %s (with %s but no %s)."),
637 N_(
"?extra:Allows %s (with %s)."),
639 N_(
"?extra:Allows %s (absent %s)."),
641 N_(
"?extra:Allows %s."),
643 N_(
"?extra:Prevents %s.")
651 static const char *
const gstrs[] = {
653 N_(
"?good:Allows %s (with %s but no %s)."),
655 N_(
"?good:Allows %s (with %s)."),
657 N_(
"?good:Allows %s (absent %s)."),
659 N_(
"?good:Allows %s."),
661 N_(
"?good:Prevents %s.")
695 for (
ta =
ha->topic,
tb =
hb->topic; *
ta !=
'\0' && *
tb !=
'\0';
ta++,
tb++) {
697 if (*
tb ==
' ')
return -1;
699 }
else if (*
tb !=
' ') {
700 if (*
ta ==
' ')
return 1;
715 const char *filename;
744 log_error(
"failed reading help-texts from '%s':\n%s", filename,
957 const char *
nodesc =
_(
"Current ruleset contains no summary.");
1003 if (description !=
NULL) {
1008 if (summary !=
NULL) {
1009 if (version[0] !=
'\0') {
1031 const char *
nodesc =
_(
"Current tileset contains no summary.");
1033 if (version[0] !=
'\0') {
1057 if (description !=
NULL) {
1077 if (description !=
NULL) {
1082 if (summary !=
NULL) {
1083 if (version !=
NULL && version[0] !=
'\0') {
1105 const char *
nodesc =
_(
"Current musicset contains no summary.");
1107 if (version !=
NULL && version[0] !=
'\0') {
1131 if (description !=
NULL) {
1158 if (pmul->helptext) {
1159 const char *
sep =
"";
1184 "%s%s",
"\n\n", text);
1294 static char vtext[256];
1299 char *p =
ptmp->topic;
1319 _(
"Sorry, no help topic for %s.\n"),
vitem.topic);
1323 _(
"Sorry, no help topic for %s.\n"
1324 "This page was auto-generated.\n\n"),
1387 .value = {.building = pimprove}
1393 if (
NULL == pimprove) {
1416 _(
"%s The discovery of %s will make %s obsolete.\n"),
1424 _(
"%s The presence of %s in the city will make %s "
1434 _(
"%s A 'small wonder': at most one of your cities may "
1435 "possess this improvement.\n"),
BULLET);
1475 _(
"%s Allows all players with knowledge of %s "
1476 "to build %s units.\n"),
BULLET,
1484 _(
"%s Allows all players with knowledge of required "
1485 "techs to build %s units.\n"),
BULLET,
1491 _(
"%s Allows all players to build %s units.\n"),
BULLET,
1529 if (!
preq->present) {
1553 _(
"%s Makes it possible to target the city building it "
1554 "with the action \'%s\'.\n"),
BULLET,
1562 _(
"%s Makes it possible to target its city with the "
1563 "action \'%s\'.\n"),
BULLET,
1571 _(
"%s Makes it possible to target its city and its "
1572 "trade partners with the action \'%s\'.\n"),
1581 _(
"%s Makes it possible to target all cities with its "
1582 "owner on its continent with the action \'%s\'.\n"),
1591 _(
"%s Makes it possible to target all cities with its "
1592 "owner with the action \'%s\'.\n"),
1601 _(
"%s Makes it possible to target all cities on the "
1602 "same team with the action \'%s\'.\n"),
1611 _(
"%s Makes it possible to target all cities owned by "
1612 "or allied to its owner with the action \'%s\'.\n"),
1621 _(
"%s Makes it possible to target all cities with the "
1622 "action \'%s\'.\n"),
1630 log_error(
"The range %s is invalid for buildings.",
1674 if (
preq->present) {
1697 _(
"%s Makes it impossible to do the action \'%s\' to "
1698 "the city building it.\n"),
1705 _(
"%s Makes it impossible to do the action \'%s\' to "
1713 _(
"%s Makes it impossible to do the action \'%s\' to "
1714 "its city or to its city's trade partners.\n"),
1721 _(
"%s Makes it impossible to do the action \'%s\' to "
1722 "any city with its owner on its continent.\n"),
1729 _(
"%s Makes it impossible to do the action \'%s\' to "
1730 "any city with its owner.\n"),
1737 _(
"%s Makes it impossible to do the action \'%s\' to "
1738 "any city on the same team.\n"),
1745 _(
"%s Makes it impossible to do the action \'%s\' to "
1746 "any city allied to or owned by its owner.\n"),
1753 _(
"%s Makes it impossible to do the action \'%s\' to "
1754 "any city in the game.\n"),
1762 log_error(
"The range %s is invalid for buildings.",
1778 _(
"%s All players start with this improvement in their "
1779 "first city.\n"),
BULLET);
1801 _(
"%s The %s start with this improvement in their "
1802 "first city.\n"),
BULLET,
1812 _(
"%s If you lose the city containing this improvement, "
1813 "it will be rebuilt for free in another of your cities "
1814 "(if the 'savepalace' server setting is enabled).\n"),
1903 _(
" %s Is unreachable. Most units cannot attack this one.\n"),
1910 _(
" %s Doesn't prevent enemy cities from working the tile it's on.\n"),
1918 if (helptxt !=
NULL) {
1955 _(
"%s Belongs to %s unit class."),
1985 _(
" %s Gets a %d%% defensive bonus while in cities.\n"),
1993 _(
" %s Doesn't prevent enemy units from attacking other "
1994 "units on its tile.\n"),
BULLET);
2000 _(
" %s Can attack units on non-native tiles.\n"),
BULLET);
2029 _(
"%s %d%% defense bonus if attacked by %s.\n"),
2037 _(
"%s Reduces target's defense to 1 / %d when "
2038 "attacking %s.\n"),
BULLET,
2045 _(
"%s Reduces target's firepower to 1 when "
2046 "attacking %s.\n"),
BULLET,
2052 _(
"%s %d%% defense bonus if attacked by %s.\n"),
2059 _(
"%s Reduces target's defense to 1 / %.2f when "
2060 "attacking %s.\n"),
BULLET,
2061 ((
float)
cbonus->value + 100.0f) / 100.0f,
2067 _(
"%s %d%% defense bonus "
2068 "instead of any bonuses from city improvements "
2069 "if attacked by %s in a city.\n"),
2098 "are allowed.\n"),
BULLET);
2117 if (!pnation->init_units[
i]) {
2119 }
else if (pnation->init_units[
i] == utype) {
2126 PL_(
"%s The %s start the game with %d of these units.\n",
2127 "%s The %s start the game with %d of these units.\n",
2137 if (
utype2->converted_to == utype
2148 _(
"%s May be obtained by conversion of %s.\n"),
2166 _(
"%s Each player may only have one of this type of unit.\n"),
2173 if (helptxt !=
NULL) {
2180 PL_(
"%s Costs %d population to build.\n",
2181 "%s Costs %d population to build.\n", utype->
pop_cost),
2198 PL_(
"%s Can carry and refuel %d %s unit.\n",
2199 "%s Can carry and refuel up to %d %s units.\n",
2227 _(
" %s Some cargo cannot be loaded except in a city or a "
2228 "base native to this transport.\n"),
BULLET);
2233 _(
" %s Cargo cannot be loaded except in a city or a "
2234 "base native to this transport.\n"),
BULLET);
2242 _(
" %s Some cargo cannot be unloaded except in a city or a "
2243 "base native to this transport.\n"),
BULLET);
2248 _(
" %s Cargo cannot be unloaded except in a city or a "
2249 "base native to this transport.\n"),
BULLET);
2313 _(
"%s May load onto and unload from %s transports even "
2314 "when underway.\n"),
2320 _(
"%s May load onto %s transports even when underway.\n"),
2340 _(
"%s May unload from %s transports even when underway.\n"),
2355 CATLSTR(
buf,
bufsz,
_(
"%s Will never lose a diplomat-versus-diplomat fight.\n"),
2364 _(
"%s Is invisible except when next to an enemy unit or city.\n"),
2369 _(
"%s Can only attack units on native tiles.\n"),
BULLET);
2373 _(
"%s Gets double firepower when attacking cities.\n"),
BULLET);
2379 _(
"%s Ignores terrain effects (moving costs at most %s MP "
2391 "by other units.\n"),
BULLET);
2395 _(
"%s A non-military unit:\n"),
BULLET);
2398 _(
" %s Cannot attack.\n"),
BULLET);
2401 _(
" %s Doesn't impose martial law.\n"),
BULLET);
2404 _(
" %s Can enter foreign territory regardless of peace treaty.\n"),
2408 _(
" %s Doesn't prevent enemy cities from working the tile it's on.\n"),
2413 _(
"%s A field unit: one unhappiness applies even when non-aggressive.\n"),
2420 _(
"%s An enemy unit considering to auto attack this unit will "
2421 "choose to do so even if it has better odds when defending "
2422 "against it than when attacking it.\n"),
BULLET);
2429 _(
"%s Under certain conditions the shield upkeep of this unit can "
2430 "be converted to gold upkeep.\n"),
BULLET);
2437 _(
"%s Can attack against %s units, which are usually not "
2458 _(
"%s Unit has to end each turn next to safe coast or"
2459 " in a city or a base.\n"),
BULLET);
2465 PL_(
"%s Unit has to be next to safe coast, in a city or a base"
2466 " after %d turn.\n",
2467 "%s Unit has to be next to safe coast, in a city or a base"
2468 " after %d turns.\n",
2474 PL_(
"%s Unit has to be in a city or a base"
2475 " after %d turn.\n",
2476 "%s Unit has to be in a city or a base"
2477 " after %d turns.\n",
2487 PL_(
"%s Unit has to be next to safe coast, in a city, a base, or on a %s"
2488 " after %d turn.\n",
2489 "%s Unit has to be next to safe coast, in a city, a base, or on a %s"
2490 " after %d turns.\n",
2496 PL_(
"%s Unit has to be in a city, a base, or on a %s"
2497 " after %d turn.\n",
2498 "%s Unit has to be in a city, a base, or on a %s"
2499 " after %d turns.\n",
2527 _(
"%s Will never be forced (by the autoattack server setting)"
2528 " to attack units moving to an adjacent tile.\n"),
BULLET);
2549 _(
"%s Can do the action \'%s\'.\n"),
2577 _(
"extras among "));
2592 _(
" %s is done to %s%s%s.\n"),
BULLET,
2602 _(
" %s uses up the %s.\n"),
BULLET,
2610 _(
" %s can lead to a %s against a defender.\n"),
2619 { .kind =
VUT_UTYPE, .value.utype = utype },
2630 _(
" %s may fail because of a dice throw.\n"),
2640 _(
" %s the %s may be captured while trying to"
2641 " escape after completing the mission.\n"),
2652 _(
" %s ends this unit's turn.\n"),
2662 _(
" %s ending up on a native tile"
2663 " after this action has been performed"
2664 " ends this unit's turn.\n"),
BULLET);
2681 if (
paction->min_distance == 0) {
2685 _(
" %s target must be at the same tile.\n"),
2691 PL_(
" %s target must be exactly %d tile away.\n",
2692 " %s target must be exactly %d tiles away.\n",
2699 if (
paction->min_distance == 0) {
2703 _(
" %s target can be anywhere.\n"),
BULLET);
2708 PL_(
" %s target must be at least %d tile away.\n",
2709 " %s target must be at least %d tiles away.\n",
2713 }
else if (
paction->min_distance == 0) {
2719 PL_(
" %s target can be max %d tile away.\n",
2720 " %s target can be max %d tiles away.\n",
2729 PL_(
" %s target must be between %d and %d tile away.\n",
2730 " %s target must be between %d and %d tiles away.\n",
2739 const enum effect_type
eft;
2794 _(
" %s %s performing this action during %s causes"
2795 " international outrage: the whole world gets "
2796 "Casus Belli against you.\n"),
BULLET,
2806 _(
" %s %s performing this action during %s gives"
2807 " the victim Casus Belli against you.\n"),
2823 _(
" %s adds %d production.\n"),
BULLET,
2830 { .kind =
VUT_UTYPE, .value.utype = utype },
2834 _(
" %s restores up to %d%% of the target unit's"
2835 " hit points.\n"),
BULLET,
2846 _(
" %s is disabled in the current game.\n"),
2851 PL_(
" %s initial population: %d.\n",
2852 " %s initial population: %d.\n",
2859 PL_(
" %s max target size: %d.\n",
2860 " %s max target size: %d.\n",
2865 PL_(
" %s adds %d population.\n",
2866 " %s adds %d population.\n",
2873 _(
" %s %d per turn.\n"),
BULLET,
2877 _(
" %s Will damage all"
2878 " defenders on a tile, and have no risk for the"
2879 " attacker.\n"),
BULLET);
2884 _(
" %s upgraded to %s or, when possible, to the unit "
2885 "type it upgrades to.\n"),
BULLET,
2891 _(
" %s weaker when tired. If performed with less "
2892 "than a single move point left the attack power "
2893 "is reduced accordingly.\n"),
BULLET);
2898 _(
" %s can wipe stack of units with zero defense.\n"),
2904 PL_(
" %s is converted into %s (takes %d MP).\n",
2905 " %s is converted into %s (takes %d MP).\n",
2917 _(
" %s %d%% of the population of each city inside"
2918 " the nuclear blast dies.\n"),
BULLET,
2922 _(
" %s can never destroy city completely "
2923 "(%d%% of size 1 rounds down to 0).\n"),
BULLET,
2927 _(
" %s can even destroy city completely "
2928 "(%d%% of size 1 rounds up to 1).\n"),
BULLET,
2934 _(
" %s all units caught in the open by the nuclear"
2935 " blast die.\n"),
BULLET);
2938 _(
" %s a unit caught in the nuclear blast while"
2939 " inside a city has a %d%% chance of survival.\n"),
2944 _(
" %s all units caught in the nuclear blast"
2950 { .kind =
VUT_UTYPE, .value.utype = utype },
2959 _(
" %s has a squared blast radius of %d.\n"),
2968 _(
" %s converts target tile terrain to another"
3045 { .kind =
VUT_UTYPE, .value = { .utype = utype }},
3055 .value = { .utype = utype }},
3061 _(
" %s to stay put. No defensive bonus.\n"),
3063 }
else if (bonus > 0) {
3067 _(
" %s granting a %d%% defensive bonus.\n"),
3117 _(
" %s if a suitable hut is at the targetet tile it"
3118 " will be entered.\n"),
BULLET);
3124 _(
" %s if a suitable hut is at the targetet tile it"
3125 " will be frightened.\n"),
BULLET);
3132 _(
" %s the %s may end up loaded into a transport if it"
3133 " can't survive on its own at the target tile.\n"),
3139 _(
" %s These attacks will only damage (never kill)"
3140 " defenders.\n"),
BULLET);
3172 _(
" %s can't be done if %s is legal.\n"),
BULLET,
3177 for (;
i > 0;
i--) {
3217 _(
"%s Doing the action \'%s\' to this unit"
3218 " is impossible.\n"),
BULLET,
3244 _(
" %s Veterans have increased strength in combat.\n"),
3252 _(
" %s Veterans have improved chances in diplomatic "
3257 _(
" %s Veterans are more likely to survive missions.\n"),
3264 _(
" %s Veterans work faster.\n"),
BULLET);
3275 _(
"This type of unit has its own veteran levels:"),
NULL)) {
3301 .value = {.advance =
vap}
3322 if (
NULL != pplayer) {
3330 PL_(
"Starting now, researching %s would need %d bulb.",
3331 "Starting now, researching %s would need %d bulbs.",
3342 PL_(
" The whole project will require %d bulb to complete.",
3343 " The whole project will require %d bulbs to complete.",
3348 PL_(
"To research %s you need to research %d other"
3349 " technology first.%s",
3350 "To research %s you need to research %d other"
3351 " technologies first.%s",
3357 _(
"You cannot research this technology."));
3363 _(
" This number may vary depending on what "
3364 "other players research.\n"));
3392 _(
"%s All players start the game with knowledge of this "
3393 "technology.\n"),
BULLET);
3409 if (pnation->init_techs[j] ==
A_LAST) {
3411 }
else if (pnation->init_techs[j] ==
i) {
3414 _(
"%s The %s start the game with knowledge of this "
3415 "technology.\n"),
BULLET,
3469 _(
"%s Only those who know %s can acquire this "
3470 "technology (by any means).\n"),
3479 _(
"%s The first player to learn %s gets"
3480 " an immediate advance.\n"),
BULLET,
3488 if (helptxt !=
NULL) {
3496 _(
"%s To preserve this technology for our nation some bulbs "
3497 "are needed each turn.\n"),
BULLET);
3520 .value = {.terrain = pterrain}
3536 _(
"%s You cannot build cities on this terrain.\n"),
3542 if (pextra->buildable) {
3544 _(
"%s Paths cannot be built on this terrain.\n"),
3553 if (pextra->buildable) {
3555 _(
"%s Bases cannot be built on this terrain.\n"),
3564 _(
"%s The coastline of this terrain is unsafe.\n"),
3588 _(
"%s Units on this terrain neither impose zones of control "
3589 "nor are restricted by them.\n"),
BULLET);
3592 _(
"%s Units on this terrain may impose a zone of control, or "
3593 "be restricted by one.\n"),
BULLET);
3599 if (helptxt !=
NULL) {
3606 if (
buf[0] !=
'\0') {
3628 static char str[64];
3638 int bonus =
proad->tile_bonus[
o];
3645 if (
str[0] !=
'\0') {
3648 if (
incr == 0 && bonus == 0) {
3665 &&
proad->tile_incr[
o] == 0
3666 &&
proad->tile_bonus[
o] == 0);
3686 { .kind =
VUT_TERRAIN, .value.terrain = pterrain },
3713 bonus[
o] +=
proad->tile_incr_const[
o]
3737 if (bonus[
o] > 0 || pterrain->
output[
o] > 0) {
3759 static char buffer[256];
3769 PL_(
", +%d food",
", +%d food", bonus[0]), bonus[0]);
3773 PL_(
", +%d shield",
", +%d shields", bonus[1]), bonus[1]);
3777 PL_(
", +%d trade",
", +%d trade", bonus[2]), bonus[2]);
3797 .value = {.extra = pextra}
3835 _(
"Build by issuing an \"irrigate\" order.\n"));
3839 _(
"Build by issuing a \"mine\" order.\n"));
3843 _(
"Build by issuing a \"road\" order.\n"));
3850 _(
"Build by issuing a \"build base\" order.\n"));
3852 const char *order =
"";
3854 switch (
pbase->gui_type) {
3867 _(
"Build by issuing a \"%s\" order.\n"), order);
3874 _(
"May randomly appear around polluting city.\n"));
3879 _(
"May randomly appear around nuclear blast.\n"));
3887 _(
"Placed by map generator.\n"));
3892 _(
"Can be explored by certain units.\n"));
3897 _(
"May appear spontaneously.\n"));
3929 int pillage_time = -1;
3939 if (pillage_time < 0) {
3949 if (pillage_time < 0) {
3951 _(
"Can be pillaged by units (time is terrain-dependent).\n"));
3952 }
else if (pillage_time > 0) {
3954 PL_(
"Can be pillaged by units (takes %d turn).\n",
3955 "Can be pillaged by units (takes %d turns).\n",
3956 pillage_time), pillage_time);
3985 _(
"Can be cleaned by units (time is terrain-dependent).\n"));
3988 PL_(
"Can be cleaned by units (takes %d turn).\n",
3989 "Can be cleaned by units (takes %d turns).\n",
4027 _(
"%s Visible only if %s known.\n"),
BULLET,
4034 _(
"%s Units inside are hidden from non-allied players.\n"),
4067 _(
" %s Such units can move onto this tile even if it would "
4068 "not normally be suitable terrain.\n"),
BULLET);
4074 PL_(
" %s Such units situated here are not considered aggressive "
4075 "if this tile is within %d tile of a friendly city.\n",
4076 " %s Such units situated here are not considered aggressive "
4077 "if this tile is within %d tiles of a friendly city.\n",
4085 _(
" %s Such units get a %d%% defense bonus on this "
4107 _(
"%s Can be conquered by %s.\n"),
BULLET,
4114 if (
proad->move_cost == 0) {
4120 _(
"%s Movement cost along %s is %s MP.\n"),
4130 _(
"%s Defeat of one unit does not cause death of all other units "
4131 "on this tile.\n"),
BULLET);
4136 _(
"%s Extends national borders of the building nation.\n"),
4139 if (
pbase->vision_main_sq >= 0) {
4141 _(
"%s Grants permanent vision of an area around the tile to "
4142 "its owner.\n"),
BULLET);
4144 if (
pbase->vision_invis_sq >= 0) {
4146 _(
"%s Allows the owner to see normally invisible stealth units "
4147 "in an area around the tile.\n"),
BULLET);
4149 if (
pbase->vision_subs_sq >= 0) {
4151 _(
"%s Allows the owner to see normally invisible subsurface units "
4152 "in an area around the tile.\n"),
BULLET);
4159 if (helptxt !=
NULL) {
4176 if (
proad->tile_incr[
o] > 0) {
4189 _(
"\nTime to build and output bonus depends on terrain:\n\n"));
4193 _(
"Terrain Time Bonus F/P/T\n"
4194 "----------------------------------\n"));
4197 _(
"\nTime to build depends on terrain:\n\n"));
4202 "------------------\n"));
4208 _(
"\nYields an output bonus with some terrains:\n\n"));
4210 _(
"Terrain Bonus F/P/T\n"
4211 "-------------------------\n"));
4268 if (
pgood->onetime_pct == 0) {
4270 _(
"There's no bonuses paid when trade route gets established.\n\n"));
4271 }
else if (
pgood->onetime_pct != 100) {
4273 _(
"When trade route gets established, %d%% of the normal bonus is paid.\n"),
4274 pgood->onetime_pct);
4341 .value = {.govern = gov}
4384 if (!
preq->present ||
preq->quiet) {
4388 switch (
preq->source.kind) {
4406 unittype =
preq->source.value.utype;
4410 unitflag =
preq->source.value.unitflag;
4459 .unittype = unittype,
4504 PL_(
"%s Military units away from home and field units"
4505 " will each cause %d citizen to become unhappy.\n",
4506 "%s Military units away from home and field units"
4507 " will each cause %d citizens to become unhappy.\n",
4517 _(
"%s Unhappiness from foreign citizens due to "
4518 "war with their home state is %d%% the usual "
4523 _(
"%s No unhappiness from foreign citizens even when "
4524 "at war with their home state.\n"),
BULLET);
4530 _(
"%s Each foreign citizen causes %.2g unhappiness "
4531 "in their city while you are at war with their "
4532 "home state.\n"),
BULLET,
4540 PL_(
"%s Each of your cities will avoid %d unhappiness"
4541 " caused by units.\n",
4542 "%s Each of your cities will avoid %d unhappiness"
4543 " caused by units.\n",
4551 PL_(
"%s Each of your cities will avoid %d unhappiness,"
4552 " not including that caused by aggression.\n",
4553 "%s Each of your cities will avoid %d unhappiness,"
4554 " not including that caused by aggression.\n",
4562 PL_(
"%s Each of your cities will avoid %d unhappiness,"
4563 " including that caused by aggression.\n",
4564 "%s Each of your cities will avoid %d unhappiness,"
4565 " including that caused by aggression.\n",
4577 _(
"%s You pay no %s upkeep for your units.\n"),
4581 _(
"%s You pay no upkeep for your units.\n"),
4590 _(
"%s You pay %.2g times normal %s upkeep for your "
4595 _(
"%s You pay %.2g times normal upkeep for your "
4610 PL_(
"%s Each of your cities will avoid paying %d %s"
4611 " upkeep for your units.\n",
4612 "%s Each of your cities will avoid paying %d %s"
4613 " upkeep for your units.\n",
peffect->value),
4620 PL_(
"%s Each of your cities will avoid paying %d"
4621 " upkeep for your units.\n",
4622 "%s Each of your cities will avoid paying %d"
4623 " upkeep for your units.\n",
peffect->value),
4631 _(
"%s If you lose your capital,"
4632 " the base chance of civil war is %d%%.\n"),
4639 PL_(
"%s You can have %d city before an "
4640 "additional unhappy citizen appears in each city "
4641 "due to civilization size.\n",
4642 "%s You can have up to %d cities before an "
4643 "additional unhappy citizen appears in each city "
4644 "due to civilization size.\n",
net_value),
4651 PL_(
"%s After the first unhappy citizen due to"
4652 " civilization size, for each %d additional city"
4653 " another unhappy citizen will appear.\n",
4654 "%s After the first unhappy citizen due to"
4655 " civilization size, for each %d additional cities"
4656 " another unhappy citizen will appear.\n",
4665 _(
"%s The maximum rate you can set for science,"
4666 " gold, or luxuries is %d%%.\n"),
4670 _(
"%s Has unlimited science/gold/luxuries rates.\n"),
4678 PL_(
"%s Your units may impose martial law."
4679 " Each military unit inside a city will force %d"
4680 " unhappy citizen to become content.\n",
4681 "%s Your units may impose martial law."
4682 " Each military unit inside a city will force %d"
4683 " unhappy citizens to become content.\n",
4691 PL_(
"%s A maximum of %d unit in each city can enforce"
4693 "%s A maximum of %d units in each city can enforce"
4702 _(
"%s You may grow your cities by means of "
4703 "celebrations."),
BULLET);
4708 _(
" (Cities below size %d cannot grow in this way.)"),
4717 PL_(
"%s If a city is in disorder for more than %d turn "
4718 "in a row, government will fall into anarchy.\n",
4719 "%s If a city is in disorder for more than %d turns "
4720 "in a row, government will fall into anarchy.\n",
4728 _(
"%s Has a senate that may prevent declaration of war.\n"),
4735 _(
"%s Allows partisans when cities are taken by the "
4742 _(
"%s Buildings that normally confer bonuses against"
4743 " unhappiness will instead give gold.\n"),
BULLET);
4758 _(
"%s Pays no upkeep for %s.\n"),
BULLET,
4791 Q_(
"?unitclass:* New %s units will be veteran.\n"),
4797 Q_(
"?unitflag:* New %s units will be veteran.\n"),
4799 }
else if (unittype !=
NULL) {
4809 Q_(
"?unittype:%s New %s units will have the rank "
4818 _(
"%s New units will be veteran.\n"),
BULLET);
4828 PL_(
"%s Each worked tile that gives more than %d %s will"
4829 " suffer a -1 penalty, unless the city working it"
4831 "%s Each worked tile that gives more than %d %s will"
4832 " suffer a -1 penalty, unless the city working it"
4839 _(
" (Cities below size %d will not celebrate.)"),
4848 PL_(
"%s Each worked tile with at least 1 %s will yield"
4849 " %d more of it while the city working it is"
4851 "%s Each worked tile with at least 1 %s will yield"
4852 " %d more of it while the city working it is"
4853 " celebrating.",
peffect->value),
4859 _(
" (Cities below size %d will not celebrate.)"),
4867 PL_(
"%s Each worked tile with at least 1 %s will yield"
4868 " %d more of it.\n",
4869 "%s Each worked tile with at least 1 %s will yield"
4870 " %d more of it.\n",
peffect->value),
4878 _(
"%s %s production is increased %d%%.\n"),
4886 _(
"%s %s production will suffer massive losses.\n"),
4891 _(
"%s %s production will suffer some losses.\n"),
4896 _(
"%s %s production will suffer a small amount "
4906 " within your cities.\n"),
BULLET);
4907 }
else if (
peffect->value < 0) {
4909 " within your cities.\n"),
BULLET);
4924 _(
"%s %s losses will increase quickly"
4925 " with distance from capital.\n"),
4930 _(
"%s %s losses will increase"
4931 " with distance from capital.\n"),
4936 _(
"%s %s losses will increase slowly"
4937 " with distance from capital.\n"),
4946 " into your cities.\n"),
BULLET);
4947 }
else if (
peffect->value < 0) {
4949 " into your cities.\n"),
BULLET);
4957 " monitored.\n"),
BULLET);
4982 _(
"%s Makes it impossible to do the action \'%s\'"
4983 " to your %s.\n"),
BULLET,
4999 static char buf[128];
5012 (any > 0 ?
Q_(
"?blistmore:, ") :
""), utype->
upkeep[
o],
5020 (any > 0 ?
Q_(
"?blistmore:, ") :
""), utype->
happy_cost);
5039 .value = {.nation = pnation}
5043#define PRINT_BREAK() do { \
5044 if (print_break) { \
5045 if (buf[0] != '\0') { \
5046 CATLSTR(buf, bufsz, "\n\n"); \
5048 print_break = FALSE; \
5055 if (pnation->
legend[0] !=
'\0') {
5063 _(
"Initial government is %s.\n"),
5083 _(
"Starts with knowledge of %s in addition to the standard "
5095 int i, j,
n = 0, total = 0;
5102 for (j = 0; j <
n; j++) {
5121 for (
i = 0;
i <
n;
i++) {
5136 for (
i = 0;
i <
n;
i++) {
5141 for (
i = 0;
i <
n;
i++) {
5149 PL_(
"Starts with the following additional unit: %s.\n",
5150 "Starts with the following additional units: %s.\n",
5173 _(
"First city will get %s for free in addition to the "
5183 if (
buf[0] !=
'\0') {
5189 if (
buf[0] !=
'\0') {
enum action_actor_kind action_get_actor_kind(const struct action *paction)
const char * action_id_name_translation(action_id act_id)
void action_array_add_all_by_result(action_id *act_array, int *position, enum action_result result)
const char * action_name_translation(const struct action *paction)
void action_array_end(action_id *act_array, int size)
bool action_is_in_use(struct action *paction)
enum action_sub_target_kind action_get_sub_target_kind(const struct action *paction)
bool action_would_be_blocked_by(const struct action *blocked, const struct action *blocker)
bool action_immune_government(struct government *gov, action_id act)
int action_dice_roll_initial_odds(const struct action *paction)
const char * action_target_kind_help(enum action_target_kind kind)
enum action_target_kind action_get_target_kind(const struct action *paction)
struct action_enabler_list * action_enablers_for_action(action_id action)
#define action_id_univs_not_blocking(act_id, act_uni, tgt_uni)
#define action_auto_perf_iterate_end
static struct action * action_by_number(action_id act_id)
#define action_array_iterate(_act_array_, _act_id_)
#define action_has_result(_act_, _res_)
#define action_enabler_list_iterate_end
#define action_id_get_role(act_id)
#define ACTION_DISTANCE_UNLIMITED
#define action_array_iterate_end
#define action_iterate_end
#define action_enabler_list_iterate(action_enabler_list, aenabler)
#define action_iterate(_act_)
#define action_id_get_target_kind(act_id)
#define action_auto_perf_iterate(_act_perf_)
#define ACTION_ODDS_PCT_DICE_ROLL_NA
bool actres_removes_extra(enum action_result result, const struct extra_type *pextra)
bool actres_creates_extra(enum action_result result, const struct extra_type *pextra)
enum action_battle_kind actres_get_battle_kind(enum action_result result)
void astr_free(struct astring *astr)
const char * astr_build_or_list(struct astring *astr, const char *const *items, size_t number)
void astr_set(struct astring *astr, const char *format,...)
const char * astr_build_and_list(struct astring *astr, const char *const *items, size_t number)
void astr_init(struct astring *astr)
static const char * astr_str(const struct astring *astr) fc__attribute((nonnull(1)))
bool territory_claiming_base(const struct base_type *pbase)
#define BV_CLR_ALL_FROM(vec_to, vec_from)
#define BV_ARE_EQUAL(vec1, vec2)
#define BV_ISSET(bv, bit)
#define BV_ISSET_ANY(vec)
struct output_type * get_output_type(Output_type_id output)
const char * get_output_name(Output_type_id output)
#define output_type_iterate(output)
#define output_type_iterate_end
enum client_states client_state(void)
bool client_nation_is_in_current_set(const struct nation_type *pnation)
static struct fc_sockaddr_list * list
const char * counter_name_translation(const struct counter *counter)
struct counter * counter_by_id(int id)
static void road(QVariant data1, QVariant data2)
bool effect_universals_value_never_below(enum effect_type type, struct universal *unis, size_t n_unis, int min_value)
int effect_value_from_universals(enum effect_type type, struct universal *unis, size_t n_unis)
int get_target_bonus_effects(struct effect_list *plist, const struct req_context *context, const struct req_context *other_context, enum effect_type effect_type)
int effect_cumulative_max(enum effect_type type, struct universal *unis, size_t n_unis)
struct effect_list * get_req_source_effects(const struct universal *psource)
bool building_has_effect(const struct impr_type *pimprove, enum effect_type effect_type)
#define effect_list_iterate_end
#define effect_list_iterate(effect_list, peffect)
#define MAX_NUM_BUILDING_LIST
#define CASUS_BELLI_OUTRAGE
#define CASUS_BELLI_VICTIM
#define MAX_NUM_UNIT_LIST
#define MAX_NUM_TECH_LIST
enum output_type_id Output_type_id
size_t get_internal_string_length(const char *text)
#define PL_(String1, String2, n)
const char * government_name_translation(const struct government *pgovern)
#define governments_iterate(NAME_pgov)
#define governments_iterate_end
static GtkWidget * source
const char * client_string
void insert_client_build_info(char *outbuf, size_t outlen)
void popdown_help_dialog(void)
static void extra_bonus_for_terrain(struct extra_type *pextra, struct terrain *pterrain, int *bonus)
void help_iter_start(void)
static int help_item_compar(const struct help_item *const *ppa, const struct help_item *const *ppb)
static bool help_nodes_init
void free_help_texts(void)
void boot_help_texts(void)
static void insert_allows(struct universal *psource, char *buf, size_t bufsz, const char *prefix)
#define CATLSTR(_b, _s, _t,...)
static bool insert_generated_text(char *outbuf, size_t outlen, const char *name)
static struct help_list * help_nodes
static const char *const help_type_names[]
void helptext_government(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct government *gov)
void helptext_advance(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, int i)
enum help_page_type help_type_by_requirement(const struct requirement *req)
char * helptext_unit(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, const struct unit_type *utype, bool class_help)
void helptext_extra(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct extra_type *pextra)
void helptext_unitclass(struct unit_class *pclass, char *buf, size_t bufsz)
static void check_help_nodes_init(void)
const struct help_item * get_help_item(int pos)
static bool insert_veteran_help(char *outbuf, size_t outlen, const struct veteran_system *veteran, const char *intro, const char *nolevels)
void helptext_goods(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct goods_type *pgood)
static bool show_help_for_nation(const struct nation_type *pnation)
const char * helptext_road_bonus_str(const struct terrain *pterrain, const struct road_type *proad)
static const struct help_list_link * help_nodes_iterator
char * helptext_unit_upkeep_str(const struct unit_type *utype)
const char * helptext_extra_for_terrain_str(struct extra_type *pextra, struct terrain *pterrain, enum unit_activity act)
static void insert_allows_single(struct universal *psource, struct requirement_vector *psubjreqs, const char *subjstr, const char *const *strs, char *buf, size_t bufsz, const char *prefix)
#define help_list_iterate_end
static bool utype_may_do_escape_action(const struct unit_type *utype)
void helptext_specialist(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct specialist *pspec)
const struct help_item * get_help_item_spec(const char *name, enum help_page_type htype, int *pos)
#define help_list_iterate(helplist, phelp)
const struct help_item * help_iter_next(void)
char * helptext_building(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, const struct impr_type *pimprove)
void helptext_terrain(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct terrain *pterrain)
void helptext_nation(char *buf, size_t bufsz, struct nation_type *pnation, const char *user_text)
static struct help_item * new_help_item(int type)
#define HELP_MUSICSET_ITEM
#define HELP_TILESET_ITEM
#define HELP_RULESET_ITEM
const struct impr_type * valid_improvement(const struct impr_type *pimprove)
struct impr_type * improvement_by_number(const Impr_type_id id)
bool is_great_wonder(const struct impr_type *pimprove)
bool improvement_has_flag(const struct impr_type *pimprove, enum impr_flag_id flag)
const char * improvement_name_translation(const struct impr_type *pimprove)
bool is_small_wonder(const struct impr_type *pimprove)
#define improvement_iterate_end
#define improvement_iterate(_p)
#define fc_assert_ret(condition)
#define log_verbose(message,...)
#define fc_assert(condition)
#define fc_assert_ret_val(condition, val)
#define log_error(message,...)
struct terrain_misc terrain_control
const char * move_points_text(int mp, bool reduce)
const char * move_points_text_full(int mp, bool reduce, const char *prefix, const char *none, bool align)
bool is_native_to_class(const struct unit_class *punitclass, const struct terrain *pterrain, const bv_extras *extras)
bool can_unit_type_transport(const struct unit_type *transporter, const struct unit_class *transported)
bool can_attack_non_native(const struct unit_type *utype)
#define multipliers_iterate(_mul_)
#define multipliers_iterate_end
const char * current_musicset_version(void)
const char * current_musicset_name(void)
const char * current_musicset_summary(void)
const char * current_musicset_description(void)
static const char * name_translation_get(const struct name_translation *ptrans)
const char * nation_plural_translation(const struct nation_type *pnation)
#define nations_iterate_end
#define nations_iterate(NAME_pnation)
const char * diplrel_name_translation(int value)
struct section_file * secfile_load(const char *filename, bool allow_duplicates)
const char * secfile_error(void)
const char * section_name(const struct section *psection)
void secfile_destroy(struct section_file *secfile)
void secfile_check_unused(const struct section_file *secfile)
struct section_list * secfile_sections_by_name_prefix(const struct section_file *secfile, const char *prefix)
const char ** secfile_lookup_str_vec(const struct section_file *secfile, size_t *dim, const char *path,...)
const char * secfile_lookup_str(const struct section_file *secfile, const char *path,...)
#define section_list_iterate(seclist, psection)
#define section_list_iterate_end
bool req_text_insert_nl(char *buf, size_t bufsz, struct player *pplayer, const struct requirement *preq, enum rt_verbosity verb, const char *prefix)
bool universal_is_relevant_to_requirement(const struct requirement *req, const struct universal *source)
bool universal_fulfills_requirements(bool check_necessary, const struct requirement_vector *reqs, const struct universal *source)
bool are_universals_equal(const struct universal *psource1, const struct universal *psource2)
const char * universal_name_translation(const struct universal *psource, char *buf, size_t bufsz)
#define requirement_fulfilled_by_unit_type(_ut_, _rqs_)
#define requirement_fulfilled_by_improvement(_imp_, _rqs_)
#define requirement_vector_iterate_end
#define requirement_vector_iterate(req_vec, preq)
int research_goal_unknown_techs(const struct research *presearch, Tech_type_id goal)
bool research_invention_reachable(const struct research *presearch, const Tech_type_id tech)
int research_goal_bulbs_required(const struct research *presearch, Tech_type_id goal)
int research_total_bulbs_required(const struct research *presearch, Tech_type_id tech, bool loss_value)
struct research * research_get(const struct player *pplayer)
enum tech_state research_invention_state(const struct research *presearch, Tech_type_id tech)
bool road_has_flag(const struct road_type *proad, enum road_flag_id flag)
bool road_provides_move_bonus(const struct road_type *proad)
server_setting_id server_setting_by_name(const char *name)
bool server_setting_value_bool_get(server_setting_id id)
struct setting_list * level[OLEVELS_NUM]
int compare_strings(const void *first, const void *second)
const char * fileinfoname(const struct strvec *dirs, const char *filename)
const struct strvec * get_data_dirs(void)
struct specialist * specialist_by_number(const Specialist_type_id id)
const char * specialist_plural_translation(const struct specialist *sp)
#define specialist_type_iterate_end
#define specialist_type_iterate(sp)
void strvec_destroy(struct strvec *psv)
void strvec_append(struct strvec *psv, const char *string)
const char * strvec_to_or_list(const struct strvec *psv, struct astring *astr)
struct strvec * strvec_new(void)
void strvec_clear(struct strvec *psv)
size_t strvec_size(const struct strvec *psv)
const char * strvec_to_and_list(const struct strvec *psv, struct astring *astr)
#define strvec_iterate(psv, str)
#define strvec_iterate_end
struct civ_game::@32::@35 client
struct packet_ruleset_control control
int global_init_techs[MAX_NUM_TECH_LIST]
struct packet_game_info info
int global_init_buildings[MAX_NUM_BUILDING_LIST]
struct packet_scenario_info scenario
char * ruleset_description
struct civ_game::@31 rgame
struct veteran_system * veteran
struct requirement_vector reqs
struct requirement_vector obsolete_by
struct requirement_vector reqs
int init_buildings[MAX_NUM_BUILDING_LIST]
struct government * init_government
struct unit_type * init_units[MAX_NUM_UNIT_LIST]
int init_techs[MAX_NUM_TECH_LIST]
enum borders_mode borders
int nuke_defender_survival_chance_pct
enum tech_upkeep_style tech_upkeep_style
char version[MAX_LEN_NAME]
int road_output_incr_pct[O_LAST]
struct requirement_vector build_reqs
struct veteran_system * veteran
const struct unit_type * obsoleted_by
bv_unit_classes disembarks
const struct unit_type * converted_to
struct combat_bonus_list * bonuses
struct veteran_level * definitions
int fc_snprintf(char *str, size_t n, const char *format,...)
size_t fc_strlcpy(char *dest, const char *src, size_t n)
int fc_strcasecmp(const char *str0, const char *str1)
size_t fc_strlcat(char *dest, const char *src, size_t n)
int cat_snprintf(char *str, size_t n, const char *format,...)
#define sz_strlcpy(dest, src)
#define sz_strlcat(dest, src)
#define fc_strncmp(_s1_, _s2_, _len_)
struct advance * advance_by_number(const Tech_type_id atype)
bool advance_has_flag(Tech_type_id tech, enum tech_flag_id flag)
const char * tech_class_name_translation(const struct tech_class *ptclass)
struct advance * advance_requires(const struct advance *padvance, enum tech_req require)
const char * advance_name_translation(const struct advance *padvance)
struct advance * valid_advance_by_number(const Tech_type_id id)
bool techs_have_fixed_costs(void)
const char * tech_flag_helptxt(enum tech_flag_id id)
Tech_type_id advance_number(const struct advance *padvance)
#define advance_index_iterate_end
#define advance_root_req_iterate_end
#define advance_index_iterate(_start, _index)
#define advance_root_req_iterate(_goal, _padvance)
const char * terrain_name_translation(const struct terrain *pterrain)
const char * terrain_rule_name(const struct terrain *pterrain)
enum terrain_class terrain_type_terrain_class(const struct terrain *pterrain)
const char * terrain_flag_helptxt(enum terrain_flag_id id)
int terrain_extra_build_time(const struct terrain *pterrain, enum unit_activity activity, const struct extra_type *tgt)
#define terrain_type_iterate(_p)
#define terrain_type_iterate_end
#define terrain_has_flag(terr, flag)
const char * tileset_description(struct tileset *t)
const char * tileset_summary(struct tileset *t)
const char * tileset_name_get(struct tileset *t)
const char * tileset_version(struct tileset *t)
const char * goods_name_translation(struct goods_type *pgood)
#define goods_type_iterate_end
#define goods_type_iterate(_p)
const struct impr_type * building
const char * uclass_name_translation(const struct unit_class *pclass)
bool utype_action_takes_all_mp(const struct unit_type *putype, struct action *paction)
bool utype_can_freely_unload(const struct unit_type *pcargotype, const struct unit_type *ptranstype)
const char * unit_class_flag_helptxt(enum unit_class_flag_id id)
Unit_Class_id uclass_count(void)
struct unit_type * get_role_unit(int role, int role_index)
int utype_build_shield_cost_base(const struct unit_type *punittype)
const struct veteran_system * utype_veteran_system(const struct unit_type *punittype)
int num_role_units(int role)
bool utype_can_freely_load(const struct unit_type *pcargotype, const struct unit_type *ptranstype)
Unit_type_id utype_count(void)
int utype_veteran_levels(const struct unit_type *punittype)
bool utype_can_do_action_result(const struct unit_type *putype, enum action_result result)
bool utype_action_takes_all_mp_if_ustate_is(const struct unit_type *putype, struct action *paction, const enum ustate_prop prop)
const struct veteran_level * utype_veteran_level(const struct unit_type *punittype, int level)
bool utype_is_consumed_by_action(const struct action *paction, const struct unit_type *utype)
bool utype_veteran_has_power_bonus(const struct unit_type *punittype)
const char * unit_type_flag_helptxt(enum unit_type_flag_id id)
const char * utype_name_translation(const struct unit_type *punittype)
bool can_utype_do_act_if_tgt_diplrel(const struct unit_type *punit_type, const action_id act_id, const int prop, const bool is_there)
bool utype_can_do_action(const struct unit_type *putype, const action_id act_id)
#define UCF_LAST_USER_FLAG
static bool uclass_has_flag(const struct unit_class *punitclass, enum unit_class_flag_id flag)
#define utype_fuel(ptype)
#define combat_bonus_list_iterate_end
#define combat_bonus_list_iterate(bonuslist, pbonus)
#define unit_tech_reqs_iterate_end
#define unit_class_iterate(_p)
#define unit_tech_reqs_iterate(_utype_, _p)
static bool utype_has_flag(const struct unit_type *punittype, int flag)
#define UTYF_LAST_USER_FLAG
#define unit_type_iterate(_p)
#define uclass_index(_c_)
#define unit_class_iterate_end
#define unit_type_iterate_end
const char * freeciv_name_version(void)