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) {
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"),
1887 _(
"%s Belongs to %s unit class."),
1933 _(
" %s Gets a %d%% defensive bonus while in cities.\n"),
1940 _(
" %s Is unreachable. Most units cannot attack this one.\n"),
1945 _(
" %s Doesn't prevent enemy units from attacking other "
1946 "units on its tile.\n"),
BULLET);
1953 _(
" %s Doesn't prevent enemy cities from working the tile it's on.\n"),
1959 _(
" %s Can attack units on non-native tiles.\n"),
BULLET);
1965 if (helptxt !=
NULL) {
1998 _(
"%s %d%% defense bonus if attacked by %s.\n"),
2006 _(
"%s Reduces target's defense to 1 / %d when "
2007 "attacking %s.\n"),
BULLET,
2014 _(
"%s Reduces target's firepower to 1 when "
2015 "attacking %s.\n"),
BULLET,
2021 _(
"%s %d%% defense bonus if attacked by %s.\n"),
2028 _(
"%s Reduces target's defense to 1 / %.2f when "
2029 "attacking %s.\n"),
BULLET,
2030 ((
float)
cbonus->value + 100.0f) / 100.0f,
2036 _(
"%s %d%% defense bonus "
2037 "instead of any bonuses from city improvements "
2038 "if attacked by %s in a city.\n"),
2071 "are allowed.\n"),
BULLET);
2090 if (!pnation->init_units[
i]) {
2092 }
else if (pnation->init_units[
i] == utype) {
2099 PL_(
"%s The %s start the game with %d of these units.\n",
2100 "%s The %s start the game with %d of these units.\n",
2110 if (
utype2->converted_to == utype
2121 _(
"%s May be obtained by conversion of %s.\n"),
2139 _(
"%s Each player may only have one of this type of unit.\n"),
2146 if (helptxt !=
NULL) {
2153 PL_(
"%s Costs %d population to build.\n",
2154 "%s Costs %d population to build.\n", utype->
pop_cost),
2171 PL_(
"%s Can carry and refuel %d %s unit.\n",
2172 "%s Can carry and refuel up to %d %s units.\n",
2200 _(
" %s Some cargo cannot be loaded except in a city or a "
2201 "base native to this transport.\n"),
BULLET);
2206 _(
" %s Cargo cannot be loaded except in a city or a "
2207 "base native to this transport.\n"),
BULLET);
2215 _(
" %s Some cargo cannot be unloaded except in a city or a "
2216 "base native to this transport.\n"),
BULLET);
2221 _(
" %s Cargo cannot be unloaded except in a city or a "
2222 "base native to this transport.\n"),
BULLET);
2286 _(
"%s May load onto and unload from %s transports even "
2287 "when underway.\n"),
2293 _(
"%s May load onto %s transports even when underway.\n"),
2313 _(
"%s May unload from %s transports even when underway.\n"),
2328 CATLSTR(
buf,
bufsz,
_(
"%s Will never lose a diplomat-versus-diplomat fight.\n"),
2337 _(
"%s Is invisible except when next to an enemy unit or city.\n"),
2342 _(
"%s Can only attack units on native tiles.\n"),
BULLET);
2346 _(
"%s Gets double firepower when attacking cities.\n"),
BULLET);
2352 _(
"%s Ignores terrain effects (moving costs at most %s MP "
2364 "by other units.\n"),
BULLET);
2368 _(
"%s A non-military unit:\n"),
BULLET);
2371 _(
" %s Cannot attack.\n"),
BULLET);
2374 _(
" %s Doesn't impose martial law.\n"),
BULLET);
2377 _(
" %s Can enter foreign territory regardless of peace treaty.\n"),
2381 _(
" %s Doesn't prevent enemy cities from working the tile it's on.\n"),
2386 _(
"%s A field unit: one unhappiness applies even when non-aggressive.\n"),
2393 _(
"%s An enemy unit considering to auto attack this unit will "
2394 "choose to do so even if it has better odds when defending "
2395 "against it than when attacking it.\n"),
BULLET);
2402 _(
"%s Under certain conditions the shield upkeep of this unit can "
2403 "be converted to gold upkeep.\n"),
BULLET);
2410 _(
"%s Can attack against %s units, which are usually not "
2431 _(
"%s Unit has to end each turn next to safe coast or"
2432 " in a city or a base.\n"),
BULLET);
2438 PL_(
"%s Unit has to be next to safe coast, in a city or a base"
2439 " after %d turn.\n",
2440 "%s Unit has to be next to safe coast, in a city or a base"
2441 " after %d turns.\n",
2447 PL_(
"%s Unit has to be in a city or a base"
2448 " after %d turn.\n",
2449 "%s Unit has to be in a city or a base"
2450 " after %d turns.\n",
2460 PL_(
"%s Unit has to be next to safe coast, in a city, a base, or on a %s"
2461 " after %d turn.\n",
2462 "%s Unit has to be next to safe coast, in a city, a base, or on a %s"
2463 " after %d turns.\n",
2469 PL_(
"%s Unit has to be in a city, a base, or on a %s"
2470 " after %d turn.\n",
2471 "%s Unit has to be in a city, a base, or on a %s"
2472 " after %d turns.\n",
2500 _(
"%s Will never be forced (by the autoattack server setting)"
2501 " to attack units moving to an adjacent tile.\n"),
BULLET);
2522 _(
"%s Can do the action \'%s\'.\n"),
2550 _(
"extras among "));
2565 _(
" %s is done to %s%s%s.\n"),
BULLET,
2575 _(
" %s uses up the %s.\n"),
BULLET,
2583 _(
" %s can lead to a %s against a defender.\n"),
2592 { .kind =
VUT_UTYPE, .value.utype = utype },
2603 _(
" %s may fail because of a dice throw.\n"),
2613 _(
" %s the %s may be captured while trying to"
2614 " escape after completing the mission.\n"),
2625 _(
" %s ends this unit's turn.\n"),
2635 _(
" %s ending up on a native tile"
2636 " after this action has been performed"
2637 " ends this unit's turn.\n"),
BULLET);
2654 if (
paction->min_distance == 0) {
2658 _(
" %s target must be at the same tile.\n"),
2664 PL_(
" %s target must be exactly %d tile away.\n",
2665 " %s target must be exactly %d tiles away.\n",
2672 if (
paction->min_distance == 0) {
2676 _(
" %s target can be anywhere.\n"),
BULLET);
2681 PL_(
" %s target must be at least %d tile away.\n",
2682 " %s target must be at least %d tiles away.\n",
2686 }
else if (
paction->min_distance == 0) {
2692 PL_(
" %s target can be max %d tile away.\n",
2693 " %s target can be max %d tiles away.\n",
2702 PL_(
" %s target must be between %d and %d tile away.\n",
2703 " %s target must be between %d and %d tiles away.\n",
2712 const enum effect_type
eft;
2767 _(
" %s %s performing this action during %s causes"
2768 " international outrage: the whole world gets "
2769 "Casus Belli against you.\n"),
BULLET,
2779 _(
" %s %s performing this action during %s gives"
2780 " the victim Casus Belli against you.\n"),
2796 _(
" %s adds %d production.\n"),
BULLET,
2803 { .kind =
VUT_UTYPE, .value.utype = utype },
2807 _(
" %s restores up to %d%% of the target unit's"
2808 " hit points.\n"),
BULLET,
2819 _(
" %s is disabled in the current game.\n"),
2824 PL_(
" %s initial population: %d.\n",
2825 " %s initial population: %d.\n",
2832 PL_(
" %s max target size: %d.\n",
2833 " %s max target size: %d.\n",
2838 PL_(
" %s adds %d population.\n",
2839 " %s adds %d population.\n",
2846 _(
" %s %d per turn.\n"),
BULLET,
2850 _(
" %s Will damage all"
2851 " defenders on a tile, and have no risk for the"
2852 " attacker.\n"),
BULLET);
2857 _(
" %s upgraded to %s or, when possible, to the unit "
2858 "type it upgrades to.\n"),
BULLET,
2864 _(
" %s weaker when tired. If performed with less "
2865 "than a single move point left the attack power "
2866 "is reduced accordingly.\n"),
BULLET);
2871 _(
" %s can wipe stack of units with zero defense.\n"),
2877 PL_(
" %s is converted into %s (takes %d MP).\n",
2878 " %s is converted into %s (takes %d MP).\n",
2890 _(
" %s %d%% of the population of each city inside"
2891 " the nuclear blast dies.\n"),
BULLET,
2895 _(
" %s can never destroy city completely "
2896 "(%d%% of size 1 rounds down to 0).\n"),
BULLET,
2900 _(
" %s can even destroy city completely "
2901 "(%d%% of size 1 rounds up to 1).\n"),
BULLET,
2907 _(
" %s all units caught in the open by the nuclear"
2908 " blast die.\n"),
BULLET);
2911 _(
" %s a unit caught in the nuclear blast while"
2912 " inside a city has a %d%% chance of survival.\n"),
2917 _(
" %s all units caught in the nuclear blast"
2923 { .kind =
VUT_UTYPE, .value.utype = utype },
2932 _(
" %s has a squared blast radius of %d.\n"),
2941 _(
" %s converts target tile terrain to another"
3018 { .kind =
VUT_UTYPE, .value = { .utype = utype }},
3028 .value = { .utype = utype }},
3034 _(
" %s to stay put. No defensive bonus.\n"),
3036 }
else if (bonus > 0) {
3040 _(
" %s granting a %d%% defensive bonus.\n"),
3090 _(
" %s if a suitable hut is at the targetet tile it"
3091 " will be entered.\n"),
BULLET);
3097 _(
" %s if a suitable hut is at the targetet tile it"
3098 " will be frightened.\n"),
BULLET);
3105 _(
" %s the %s may end up loaded into a transport if it"
3106 " can't survive on its own at the target tile.\n"),
3112 _(
" %s These attacks will only damage (never kill)"
3113 " defenders.\n"),
BULLET);
3145 _(
" %s can't be done if %s is legal.\n"),
BULLET,
3150 for (;
i > 0;
i--) {
3190 _(
"%s Doing the action \'%s\' to this unit"
3191 " is impossible.\n"),
BULLET,
3218 _(
" %s Veterans have increased strength in combat.\n"),
3226 _(
" %s Veterans have improved chances in diplomatic "
3231 _(
" %s Veterans are more likely to survive missions.\n"),
3238 _(
" %s Veterans work faster.\n"),
BULLET);
3249 _(
"This type of unit has its own veteran levels:"),
NULL)) {
3275 .value = {.advance =
vap}
3296 if (
NULL != pplayer) {
3304 PL_(
"Starting now, researching %s would need %d bulb.",
3305 "Starting now, researching %s would need %d bulbs.",
3316 PL_(
" The whole project will require %d bulb to complete.",
3317 " The whole project will require %d bulbs to complete.",
3322 PL_(
"To research %s you need to research %d other"
3323 " technology first.%s",
3324 "To research %s you need to research %d other"
3325 " technologies first.%s",
3331 _(
"You cannot research this technology."));
3337 _(
" This number may vary depending on what "
3338 "other players research.\n"));
3366 _(
"%s All players start the game with knowledge of this "
3367 "technology.\n"),
BULLET);
3383 if (pnation->init_techs[j] ==
A_LAST) {
3385 }
else if (pnation->init_techs[j] ==
i) {
3388 _(
"%s The %s start the game with knowledge of this "
3389 "technology.\n"),
BULLET,
3443 _(
"%s Only those who know %s can acquire this "
3444 "technology (by any means).\n"),
3453 _(
"%s The first player to learn %s gets"
3454 " an immediate advance.\n"),
BULLET,
3462 if (helptxt !=
NULL) {
3470 _(
"%s To preserve this technology for our nation some bulbs "
3471 "are needed each turn.\n"),
BULLET);
3494 .value = {.terrain = pterrain}
3510 _(
"%s You cannot build cities on this terrain.\n"),
3516 if (pextra->buildable) {
3518 _(
"%s Paths cannot be built on this terrain.\n"),
3527 if (pextra->buildable) {
3529 _(
"%s Bases cannot be built on this terrain.\n"),
3538 _(
"%s The coastline of this terrain is unsafe.\n"),
3562 _(
"%s Units on this terrain neither impose zones of control "
3563 "nor are restricted by them.\n"),
BULLET);
3566 _(
"%s Units on this terrain may impose a zone of control, or "
3567 "be restricted by one.\n"),
BULLET);
3573 if (helptxt !=
NULL) {
3580 if (
buf[0] !=
'\0') {
3602 static char str[64];
3612 int bonus =
proad->tile_bonus[
o];
3619 if (
str[0] !=
'\0') {
3622 if (
incr == 0 && bonus == 0) {
3639 &&
proad->tile_incr[
o] == 0
3640 &&
proad->tile_bonus[
o] == 0);
3660 { .kind =
VUT_TERRAIN, .value.terrain = pterrain },
3687 bonus[
o] +=
proad->tile_incr_const[
o]
3711 if (bonus[
o] > 0 || pterrain->
output[
o] > 0) {
3733 static char buffer[256];
3743 PL_(
", +%d food",
", +%d food", bonus[0]), bonus[0]);
3747 PL_(
", +%d shield",
", +%d shields", bonus[1]), bonus[1]);
3751 PL_(
", +%d trade",
", +%d trade", bonus[2]), bonus[2]);
3771 .value = {.extra = pextra}
3809 _(
"Build by issuing an \"irrigate\" order.\n"));
3813 _(
"Build by issuing a \"mine\" order.\n"));
3817 _(
"Build by issuing a \"road\" order.\n"));
3824 _(
"Build by issuing a \"build base\" order.\n"));
3826 const char *order =
"";
3828 switch (
pbase->gui_type) {
3841 _(
"Build by issuing a \"%s\" order.\n"), order);
3848 _(
"May randomly appear around polluting city.\n"));
3853 _(
"May randomly appear around nuclear blast.\n"));
3861 _(
"Placed by map generator.\n"));
3866 _(
"Can be explored by certain units.\n"));
3871 _(
"May appear spontaneously.\n"));
3903 int pillage_time = -1;
3913 if (pillage_time < 0) {
3923 if (pillage_time < 0) {
3925 _(
"Can be pillaged by units (time is terrain-dependent).\n"));
3926 }
else if (pillage_time > 0) {
3928 PL_(
"Can be pillaged by units (takes %d turn).\n",
3929 "Can be pillaged by units (takes %d turns).\n",
3930 pillage_time), pillage_time);
3959 _(
"Can be cleaned by units (time is terrain-dependent).\n"));
3962 PL_(
"Can be cleaned by units (takes %d turn).\n",
3963 "Can be cleaned by units (takes %d turns).\n",
4001 _(
"%s Visible only if %s known.\n"),
BULLET,
4008 _(
"%s Units inside are hidden from non-allied players.\n"),
4041 _(
" %s Such units can move onto this tile even if it would "
4042 "not normally be suitable terrain.\n"),
BULLET);
4048 PL_(
" %s Such units situated here are not considered aggressive "
4049 "if this tile is within %d tile of a friendly city.\n",
4050 " %s Such units situated here are not considered aggressive "
4051 "if this tile is within %d tiles of a friendly city.\n",
4059 _(
" %s Such units get a %d%% defense bonus on this "
4081 _(
"%s Can be conquered by %s.\n"),
BULLET,
4088 if (
proad->move_cost == 0) {
4094 _(
"%s Movement cost along %s is %s MP.\n"),
4104 _(
"%s Defeat of one unit does not cause death of all other units "
4105 "on this tile.\n"),
BULLET);
4110 _(
"%s Extends national borders of the building nation.\n"),
4113 if (
pbase->vision_main_sq >= 0) {
4115 _(
"%s Grants permanent vision of an area around the tile to "
4116 "its owner.\n"),
BULLET);
4118 if (
pbase->vision_invis_sq >= 0) {
4120 _(
"%s Allows the owner to see normally invisible stealth units "
4121 "in an area around the tile.\n"),
BULLET);
4123 if (
pbase->vision_subs_sq >= 0) {
4125 _(
"%s Allows the owner to see normally invisible subsurface units "
4126 "in an area around the tile.\n"),
BULLET);
4133 if (helptxt !=
NULL) {
4150 if (
proad->tile_incr[
o] > 0) {
4163 _(
"\nTime to build and output bonus depends on terrain:\n\n"));
4167 _(
"Terrain Time Bonus F/P/T\n"
4168 "----------------------------------\n"));
4171 _(
"\nTime to build depends on terrain:\n\n"));
4176 "------------------\n"));
4182 _(
"\nYields an output bonus with some terrains:\n\n"));
4184 _(
"Terrain Bonus F/P/T\n"
4185 "-------------------------\n"));;
4242 if (
pgood->onetime_pct == 0) {
4244 _(
"There's no bonuses paid when trade route gets established.\n\n"));
4245 }
else if (
pgood->onetime_pct != 100) {
4247 _(
"When trade route gets established, %d%% of the normal bonus is paid.\n"),
4248 pgood->onetime_pct);
4315 .value = {.govern = gov}
4358 if (!
preq->present ||
preq->quiet) {
4362 switch (
preq->source.kind) {
4380 unittype =
preq->source.value.utype;
4384 unitflag =
preq->source.value.unitflag;
4433 .unittype = unittype,
4478 PL_(
"%s Military units away from home and field units"
4479 " will each cause %d citizen to become unhappy.\n",
4480 "%s Military units away from home and field units"
4481 " will each cause %d citizens to become unhappy.\n",
4491 _(
"%s Unhappiness from foreign citizens due to "
4492 "war with their home state is %d%% the usual "
4497 _(
"%s No unhappiness from foreign citizens even when "
4498 "at war with their home state.\n"),
BULLET);
4504 _(
"%s Each foreign citizen causes %.2g unhappiness "
4505 "in their city while you are at war with their "
4506 "home state.\n"),
BULLET,
4514 PL_(
"%s Each of your cities will avoid %d unhappiness"
4515 " caused by units.\n",
4516 "%s Each of your cities will avoid %d unhappiness"
4517 " caused by units.\n",
4525 PL_(
"%s Each of your cities will avoid %d unhappiness,"
4526 " not including that caused by aggression.\n",
4527 "%s Each of your cities will avoid %d unhappiness,"
4528 " not including that caused by aggression.\n",
4536 PL_(
"%s Each of your cities will avoid %d unhappiness,"
4537 " including that caused by aggression.\n",
4538 "%s Each of your cities will avoid %d unhappiness,"
4539 " including that caused by aggression.\n",
4551 _(
"%s You pay no %s upkeep for your units.\n"),
4555 _(
"%s You pay no upkeep for your units.\n"),
4564 _(
"%s You pay %.2g times normal %s upkeep for your "
4569 _(
"%s You pay %.2g times normal upkeep for your "
4584 PL_(
"%s Each of your cities will avoid paying %d %s"
4585 " upkeep for your units.\n",
4586 "%s Each of your cities will avoid paying %d %s"
4587 " upkeep for your units.\n",
peffect->value),
4594 PL_(
"%s Each of your cities will avoid paying %d"
4595 " upkeep for your units.\n",
4596 "%s Each of your cities will avoid paying %d"
4597 " upkeep for your units.\n",
peffect->value),
4605 _(
"%s If you lose your capital,"
4606 " the base chance of civil war is %d%%.\n"),
4613 PL_(
"%s You can have %d city before an "
4614 "additional unhappy citizen appears in each city "
4615 "due to civilization size.\n",
4616 "%s You can have up to %d cities before an "
4617 "additional unhappy citizen appears in each city "
4618 "due to civilization size.\n",
net_value),
4625 PL_(
"%s After the first unhappy citizen due to"
4626 " civilization size, for each %d additional city"
4627 " another unhappy citizen will appear.\n",
4628 "%s After the first unhappy citizen due to"
4629 " civilization size, for each %d additional cities"
4630 " another unhappy citizen will appear.\n",
4639 _(
"%s The maximum rate you can set for science,"
4640 " gold, or luxuries is %d%%.\n"),
4644 _(
"%s Has unlimited science/gold/luxuries rates.\n"),
4652 PL_(
"%s Your units may impose martial law."
4653 " Each military unit inside a city will force %d"
4654 " unhappy citizen to become content.\n",
4655 "%s Your units may impose martial law."
4656 " Each military unit inside a city will force %d"
4657 " unhappy citizens to become content.\n",
4665 PL_(
"%s A maximum of %d unit in each city can enforce"
4667 "%s A maximum of %d units in each city can enforce"
4676 _(
"%s You may grow your cities by means of "
4677 "celebrations."),
BULLET);
4682 _(
" (Cities below size %d cannot grow in this way.)"),
4691 PL_(
"%s If a city is in disorder for more than %d turn "
4692 "in a row, government will fall into anarchy.\n",
4693 "%s If a city is in disorder for more than %d turns "
4694 "in a row, government will fall into anarchy.\n",
4702 _(
"%s Has a senate that may prevent declaration of war.\n"),
4709 _(
"%s Allows partisans when cities are taken by the "
4716 _(
"%s Buildings that normally confer bonuses against"
4717 " unhappiness will instead give gold.\n"),
BULLET);
4732 _(
"%s Pays no upkeep for %s.\n"),
BULLET,
4765 Q_(
"?unitclass:* New %s units will be veteran.\n"),
4771 Q_(
"?unitflag:* New %s units will be veteran.\n"),
4773 }
else if (unittype !=
NULL) {
4783 Q_(
"?unittype:%s New %s units will have the rank "
4792 _(
"%s New units will be veteran.\n"),
BULLET);
4802 PL_(
"%s Each worked tile that gives more than %d %s will"
4803 " suffer a -1 penalty, unless the city working it"
4805 "%s Each worked tile that gives more than %d %s will"
4806 " suffer a -1 penalty, unless the city working it"
4813 _(
" (Cities below size %d will not celebrate.)"),
4822 PL_(
"%s Each worked tile with at least 1 %s will yield"
4823 " %d more of it while the city working it is"
4825 "%s Each worked tile with at least 1 %s will yield"
4826 " %d more of it while the city working it is"
4827 " celebrating.",
peffect->value),
4833 _(
" (Cities below size %d will not celebrate.)"),
4841 PL_(
"%s Each worked tile with at least 1 %s will yield"
4842 " %d more of it.\n",
4843 "%s Each worked tile with at least 1 %s will yield"
4844 " %d more of it.\n",
peffect->value),
4852 _(
"%s %s production is increased %d%%.\n"),
4860 _(
"%s %s production will suffer massive losses.\n"),
4865 _(
"%s %s production will suffer some losses.\n"),
4870 _(
"%s %s production will suffer a small amount "
4880 " within your cities.\n"),
BULLET);
4881 }
else if (
peffect->value < 0) {
4883 " within your cities.\n"),
BULLET);
4898 _(
"%s %s losses will increase quickly"
4899 " with distance from capital.\n"),
4904 _(
"%s %s losses will increase"
4905 " with distance from capital.\n"),
4910 _(
"%s %s losses will increase slowly"
4911 " with distance from capital.\n"),
4920 " into your cities.\n"),
BULLET);
4921 }
else if (
peffect->value < 0) {
4923 " into your cities.\n"),
BULLET);
4931 " monitored.\n"),
BULLET);
4956 _(
"%s Makes it impossible to do the action \'%s\'"
4957 " to your %s.\n"),
BULLET,
4973 static char buf[128];
4986 (any > 0 ?
Q_(
"?blistmore:, ") :
""), utype->
upkeep[
o],
4994 (any > 0 ?
Q_(
"?blistmore:, ") :
""), utype->
happy_cost);
5013 .value = {.nation = pnation}
5017#define PRINT_BREAK() do { \
5018 if (print_break) { \
5019 if (buf[0] != '\0') { \
5020 CATLSTR(buf, bufsz, "\n\n"); \
5022 print_break = FALSE; \
5029 if (pnation->
legend[0] !=
'\0') {
5037 _(
"Initial government is %s.\n"),
5057 _(
"Starts with knowledge of %s in addition to the standard "
5069 int i, j,
n = 0, total = 0;
5076 for (j = 0; j <
n; j++) {
5095 for (
i = 0;
i <
n;
i++) {
5110 for (
i = 0;
i <
n;
i++) {
5115 for (
i = 0;
i <
n;
i++) {
5123 PL_(
"Starts with the following additional unit: %s.\n",
5124 "Starts with the following additional units: %s.\n",
5147 _(
"First city will get %s for free in addition to the "
5157 if (
buf[0] !=
'\0') {
5163 if (
buf[0] !=
'\0') {
const char * action_name_translation(const struct action *action)
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)
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 get_target_bonus_effects(struct effect_list *plist, const struct req_context *context, const struct player *other_player, enum effect_type effect_type)
int effect_value_from_universals(enum effect_type type, struct universal *unis, size_t n_unis)
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)
void helptext_extra(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, struct extra_type *pextra)
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)
char * helptext_unit(char *buf, size_t bufsz, struct player *pplayer, const char *user_text, const struct unit_type *utype)
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 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::@30 rgame
struct veteran_system * veteran
struct civ_game::@31::@34 client
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)