Freeciv-3.3
Loading...
Searching...
No Matches
reqtext.c
Go to the documentation of this file.
1/****************************************************************************
2 Freeciv - Copyright (C) 2004 - The Freeciv Team
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12****************************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* utility */
19#include "astring.h"
20#include "fcintl.h"
21
22/* common */
23#include "achievements.h"
24#include "actions.h"
25#include "calendar.h"
26#include "counters.h"
27#include "extras.h"
28#include "government.h"
29#include "map.h"
30#include "movement.h"
31#include "nation.h"
32#include "player.h"
33#include "requirements.h"
34#include "server_settings.h"
35#include "specialist.h"
36#include "terrain.h"
37
38#include "reqtext.h"
39
40/*************************************************************/
48bool req_text_insert(char *buf, size_t bufsz, struct player *pplayer,
49 const struct requirement *preq,
50 enum rt_verbosity verb, const char *prefix)
51{
52 if (preq->quiet && verb != VERB_ACTUAL) {
53 return FALSE;
54 }
55
56 switch (preq->source.kind) {
57 case VUT_NONE:
58 return FALSE;
59
60 case VUT_COUNTER:
61 if (preq->present) {
62
63 fc_strlcat(buf, prefix, bufsz);
64 cat_snprintf(buf, bufsz,
65 _("Requires counter %s to achieve at minimum %d value."),
66 counter_rule_name(preq->source.value.counter),
67 preq->source.value.counter->checkpoint);
68 } else {
69
70 fc_strlcat(buf, prefix, bufsz);
71 cat_snprintf(buf, bufsz,
72 _("Requires counter %s to be less than %d value."),
73 counter_rule_name(preq->source.value.counter),
74 preq->source.value.counter->checkpoint - 1);
75 }
76 break;
77 case VUT_ADVANCE:
78 switch (preq->range) {
79 case REQ_RANGE_PLAYER:
80 fc_strlcat(buf, prefix, bufsz);
81 if (preq->present) {
82 cat_snprintf(buf, bufsz,
83 _("Requires knowledge of the technology %s."),
84 advance_name_translation(preq->source.value.advance));
85 } else {
86 cat_snprintf(buf, bufsz,
87 _("Prevented by knowledge of the technology %s."),
88 advance_name_translation(preq->source.value.advance));
89 }
90 return TRUE;
91 case REQ_RANGE_TEAM:
92 fc_strlcat(buf, prefix, bufsz);
93 if (preq->present) {
94 cat_snprintf(buf, bufsz,
95 _("Requires that a player on your team knows the "
96 "technology %s."),
97 advance_name_translation(preq->source.value.advance));
98 } else {
99 cat_snprintf(buf, bufsz,
100 _("Prevented if any player on your team knows the "
101 "technology %s."),
102 advance_name_translation(preq->source.value.advance));
103 }
104 return TRUE;
105 case REQ_RANGE_ALLIANCE:
106 fc_strlcat(buf, prefix, bufsz);
107 if (preq->present) {
108 cat_snprintf(buf, bufsz,
109 _("Requires that a player allied to you knows the "
110 "technology %s."),
111 advance_name_translation(preq->source.value.advance));
112 } else {
113 cat_snprintf(buf, bufsz,
114 _("Prevented if any player allied to you knows the "
115 "technology %s."),
116 advance_name_translation(preq->source.value.advance));
117 }
118 return TRUE;
119 case REQ_RANGE_WORLD:
120 fc_strlcat(buf, prefix, bufsz);
121 if (preq->survives) {
122 if (preq->present) {
123 cat_snprintf(buf, bufsz,
124 _("Requires that someone has discovered the "
125 "technology %s."),
126 advance_name_translation(preq->source.value.advance));
127 } else {
128 cat_snprintf(buf, bufsz,
129 _("Requires that no-one has yet discovered the "
130 "technology %s."),
131 advance_name_translation(preq->source.value.advance));
132 }
133 } else {
134 if (preq->present) {
135 cat_snprintf(buf, bufsz,
136 _("Requires that some player knows the "
137 "technology %s."),
138 advance_name_translation(preq->source.value.advance));
139 } else {
140 cat_snprintf(buf, bufsz,
141 _("Requires that no player knows the "
142 "technology %s."),
143 advance_name_translation(preq->source.value.advance));
144 }
145 }
146 return TRUE;
147 case REQ_RANGE_LOCAL:
148 case REQ_RANGE_TILE:
149 case REQ_RANGE_CADJACENT:
150 case REQ_RANGE_ADJACENT:
151 case REQ_RANGE_CITY:
152 case REQ_RANGE_TRADE_ROUTE:
153 case REQ_RANGE_CONTINENT:
154 case REQ_RANGE_COUNT:
155 /* Not supported. */
156 break;
157 }
158 break;
159
160 case VUT_TECHFLAG:
161 switch (preq->range) {
162 case REQ_RANGE_PLAYER:
163 fc_strlcat(buf, prefix, bufsz);
164 if (preq->present) {
165 cat_snprintf(buf, bufsz,
166 /* TRANS: %s is a (translatable) tech flag. */
167 _("Requires knowledge of a technology with the "
168 "\"%s\" flag."),
169 tech_flag_id_translated_name(preq->source.value.techflag));
170 } else {
171 cat_snprintf(buf, bufsz,
172 /* TRANS: %s is a (translatable) tech flag. */
173 _("Prevented by knowledge of any technology with the "
174 "\"%s\" flag."),
175 tech_flag_id_translated_name(preq->source.value.techflag));
176 }
177 return TRUE;
178 case REQ_RANGE_TEAM:
179 fc_strlcat(buf, prefix, bufsz);
180 if (preq->present) {
181 cat_snprintf(buf, bufsz,
182 /* TRANS: %s is a (translatable) tech flag. */
183 _("Requires that a player on your team knows "
184 "a technology with the \"%s\" flag."),
185 tech_flag_id_translated_name(preq->source.value.techflag));
186 } else {
187 cat_snprintf(buf, bufsz,
188 /* TRANS: %s is a (translatable) tech flag. */
189 _("Prevented if any player on your team knows "
190 "any technology with the \"%s\" flag."),
191 tech_flag_id_translated_name(preq->source.value.techflag));
192 }
193 return TRUE;
194 case REQ_RANGE_ALLIANCE:
195 fc_strlcat(buf, prefix, bufsz);
196 if (preq->present) {
197 cat_snprintf(buf, bufsz,
198 /* TRANS: %s is a (translatable) tech flag. */
199 _("Requires that a player allied to you knows "
200 "a technology with the \"%s\" flag."),
201 tech_flag_id_translated_name(preq->source.value.techflag));
202 } else {
203 cat_snprintf(buf, bufsz,
204 /* TRANS: %s is a (translatable) tech flag. */
205 _("Prevented if any player allied to you knows "
206 "any technology with the \"%s\" flag."),
207 tech_flag_id_translated_name(preq->source.value.techflag));
208 }
209 return TRUE;
210 case REQ_RANGE_WORLD:
211 fc_strlcat(buf, prefix, bufsz);
212 if (preq->present) {
213 cat_snprintf(buf, bufsz,
214 /* TRANS: %s is a (translatable) tech flag. */
215 _("Requires that some player knows a technology "
216 "with the \"%s\" flag."),
217 tech_flag_id_translated_name(preq->source.value.techflag));
218 } else {
219 cat_snprintf(buf, bufsz,
220 /* TRANS: %s is a (translatable) tech flag. */
221 _("Requires that no player knows any technology with "
222 "the \"%s\" flag."),
223 tech_flag_id_translated_name(preq->source.value.techflag));
224 }
225 return TRUE;
226 case REQ_RANGE_LOCAL:
227 case REQ_RANGE_TILE:
228 case REQ_RANGE_CADJACENT:
229 case REQ_RANGE_ADJACENT:
230 case REQ_RANGE_CITY:
231 case REQ_RANGE_TRADE_ROUTE:
232 case REQ_RANGE_CONTINENT:
233 case REQ_RANGE_COUNT:
234 /* Not supported. */
235 break;
236 }
237 break;
238
239 case VUT_GOVERNMENT:
240 if (preq->range != REQ_RANGE_PLAYER) {
241 break;
242 }
243 fc_strlcat(buf, prefix, bufsz);
244 if (preq->present) {
245 cat_snprintf(buf, bufsz, _("Requires the %s government."),
246 government_name_translation(preq->source.value.govern));
247 } else {
248 cat_snprintf(buf, bufsz, _("Not available under the %s government."),
249 government_name_translation(preq->source.value.govern));
250 }
251 return TRUE;
252
253 case VUT_ACHIEVEMENT:
254 switch (preq->range) {
255 case REQ_RANGE_PLAYER:
256 fc_strlcat(buf, prefix, bufsz);
257 if (preq->present) {
258 cat_snprintf(buf, bufsz, _("Requires you to have achieved \"%s\"."),
259 achievement_name_translation(preq->source.value.achievement));
260 } else {
261 cat_snprintf(buf, bufsz, _("Not available once you have achieved "
262 "\"%s\"."),
263 achievement_name_translation(preq->source.value.achievement));
264 }
265 return TRUE;
266 case REQ_RANGE_TEAM:
267 fc_strlcat(buf, prefix, bufsz);
268 if (preq->present) {
269 cat_snprintf(buf, bufsz, _("Requires that at least one of your "
270 "team-mates has achieved \"%s\"."),
271 achievement_name_translation(preq->source.value.achievement));
272 } else {
273 cat_snprintf(buf, bufsz, _("Not available if any of your team-mates "
274 "has achieved \"%s\"."),
275 achievement_name_translation(preq->source.value.achievement));
276 }
277 return TRUE;
278 case REQ_RANGE_ALLIANCE:
279 fc_strlcat(buf, prefix, bufsz);
280 if (preq->present) {
281 cat_snprintf(buf, bufsz, _("Requires that at least one of your allies "
282 "has achieved \"%s\"."),
283 achievement_name_translation(preq->source.value.achievement));
284 } else {
285 cat_snprintf(buf, bufsz, _("Not available if any of your allies has "
286 "achieved \"%s\"."),
287 achievement_name_translation(preq->source.value.achievement));
288 }
289 return TRUE;
290 case REQ_RANGE_WORLD:
291 fc_strlcat(buf, prefix, bufsz);
292 if (preq->present) {
293 cat_snprintf(buf, bufsz, _("Requires that at least one player "
294 "has achieved \"%s\"."),
295 achievement_name_translation(preq->source.value.achievement));
296 } else {
297 cat_snprintf(buf, bufsz, _("Not available if any player has "
298 "achieved \"%s\"."),
299 achievement_name_translation(preq->source.value.achievement));
300 }
301 return TRUE;
302 case REQ_RANGE_LOCAL:
303 case REQ_RANGE_TILE:
304 case REQ_RANGE_CADJACENT:
305 case REQ_RANGE_ADJACENT:
306 case REQ_RANGE_CITY:
307 case REQ_RANGE_TRADE_ROUTE:
308 case REQ_RANGE_CONTINENT:
309 case REQ_RANGE_COUNT:
310 /* Not supported. */
311 break;
312 }
313 break;
314
315 case VUT_ACTION:
316 switch (preq->range) {
317 case REQ_RANGE_LOCAL:
318 fc_strlcat(buf, prefix, bufsz);
319 if (preq->present) {
320 cat_snprintf(buf, bufsz, _("Applies to the \"%s\" action."),
321 action_name_translation(preq->source.value.action));
322 } else {
323 cat_snprintf(buf, bufsz, _("Doesn't apply to the \"%s\""
324 " action."),
325 action_name_translation(preq->source.value.action));
326 }
327 return TRUE;
328 default:
329 /* Not supported. */
330 break;
331 }
332 break;
333
334 case VUT_IMPR_GENUS:
335 switch (preq->range) {
336 case REQ_RANGE_LOCAL:
337 fc_strlcat(buf, prefix, bufsz);
338 if (preq->present) {
339 cat_snprintf(buf, bufsz, _("Applies to \"%s\" buildings."),
340 impr_genus_id_translated_name(
341 preq->source.value.impr_genus));
342 } else {
343 cat_snprintf(buf, bufsz, _("Doesn't apply to \"%s\" buildings."),
344 impr_genus_id_translated_name(
345 preq->source.value.impr_genus));
346 }
347 return TRUE;
348 default:
349 /* Not supported. */
350 break;
351 }
352 break;
353
354 case VUT_IMPR_FLAG:
355 switch (preq->range) {
356 case REQ_RANGE_LOCAL:
357 fc_strlcat(buf, prefix, bufsz);
358 if (preq->present) {
359 cat_snprintf(buf, bufsz, _("Applies to \"%s\" buildings."),
360 impr_flag_id_translated_name(
361 preq->source.value.impr_flag));
362 } else {
363 cat_snprintf(buf, bufsz, _("Doesn't apply to \"%s\" buildings."),
364 impr_flag_id_translated_name(
365 preq->source.value.impr_flag));
366 }
367 return TRUE;
368 default:
369 /* Not supported. */
370 break;
371 }
372 break;
373
374 case VUT_PLAYER_FLAG:
375 switch (preq->range) {
376 case REQ_RANGE_PLAYER:
377 fc_strlcat(buf, prefix, bufsz);
378 if (preq->present) {
379 cat_snprintf(buf, bufsz, _("Applies to players with \"%s\" flag."),
380 plr_flag_id_translated_name(
381 preq->source.value.plr_flag));
382 } else {
383 cat_snprintf(buf, bufsz, _("Doesn't apply to players with \"%s\" flag."),
384 plr_flag_id_translated_name(
385 preq->source.value.plr_flag));
386 }
387 return TRUE;
388 default:
389 /* Not supported. */
390 break;
391 }
392 break;
393
394 case VUT_PLAYER_STATE:
395 switch (preq->range) {
396 case REQ_RANGE_PLAYER:
397 fc_strlcat(buf, prefix, bufsz);
398 if (preq->present) {
399 cat_snprintf(buf, bufsz, _("Applies to \"%s\" players."),
400 plrstate_type_translated_name(preq->source.value.plrstate));
401 } else {
402 cat_snprintf(buf, bufsz, _("Doesn't apply to \"%s\" players."),
403 plrstate_type_translated_name(preq->source.value.plrstate));
404 }
405 return TRUE;
406 default:
407 /* Not supported. */
408 break;
409 }
410 break;
411
412 case VUT_IMPROVEMENT:
413 case VUT_SITE:
414 switch (preq->range) {
415 case REQ_RANGE_WORLD:
416 if (is_great_wonder(preq->source.value.building)) {
417 fc_strlcat(buf, prefix, bufsz);
418 if (preq->survives) {
419 if (preq->present) {
420 if (preq->source.kind == VUT_IMPROVEMENT
421 && can_improvement_go_obsolete(preq->source.value.building)) {
422 cat_snprintf(buf, bufsz,
423 /* TRANS: %s is a wonder */
424 _("Requires that %s was built at some point, "
425 "and that it has not yet been rendered "
426 "obsolete."),
427 improvement_name_translation
428 (preq->source.value.building));
429 } else {
430 cat_snprintf(buf, bufsz,
431 /* TRANS: %s is a wonder */
432 _("Requires that %s was built at some point."),
433 improvement_name_translation
434 (preq->source.value.building));
435 }
436 } else {
437 if (preq->source.kind == VUT_IMPROVEMENT
438 && can_improvement_go_obsolete(preq->source.value.building)) {
439 cat_snprintf(buf, bufsz,
440 /* TRANS: %s is a wonder */
441 _("Prevented if %s has ever been built, "
442 "unless it would be obsolete."),
443 improvement_name_translation
444 (preq->source.value.building));
445 } else {
446 cat_snprintf(buf, bufsz,
447 /* TRANS: %s is a wonder */
448 _("Prevented if %s has ever been built."),
449 improvement_name_translation
450 (preq->source.value.building));
451 }
452 }
453 } else {
454 /* Non-surviving requirement */
455 if (preq->present) {
456 if (preq->source.kind == VUT_IMPROVEMENT
457 && can_improvement_go_obsolete(preq->source.value.building)) {
458 cat_snprintf(buf, bufsz,
459 /* TRANS: %s is a wonder */
460 _("Requires %s to be owned by any player "
461 "and not yet obsolete."),
462 improvement_name_translation
463 (preq->source.value.building));
464 } else {
465 cat_snprintf(buf, bufsz,
466 /* TRANS: %s is a wonder */
467 _("Requires %s to be owned by any player."),
468 improvement_name_translation
469 (preq->source.value.building));
470 }
471 } else {
472 if (preq->source.kind == VUT_IMPROVEMENT
473 && can_improvement_go_obsolete(preq->source.value.building)) {
474 cat_snprintf(buf, bufsz,
475 /* TRANS: %s is a wonder */
476 _("Prevented if %s is currently owned by "
477 "any player, unless it is obsolete."),
478 improvement_name_translation
479 (preq->source.value.building));
480 } else {
481 cat_snprintf(buf, bufsz,
482 /* TRANS: %s is a wonder */
483 _("Prevented if %s is currently owned by "
484 "any player."),
485 improvement_name_translation
486 (preq->source.value.building));
487 }
488 }
489 }
490 return TRUE;
491 }
492 /* Non-great-wonder world-ranged requirements not supported */
493 break;
494 case REQ_RANGE_ALLIANCE:
495 if (is_wonder(preq->source.value.building)) {
496 fc_strlcat(buf, prefix, bufsz);
497 if (preq->survives) {
498 if (preq->present) {
499 if (preq->source.kind == VUT_IMPROVEMENT
500 && can_improvement_go_obsolete(preq->source.value.building)) {
501 cat_snprintf(buf, bufsz,
502 /* TRANS: %s is a wonder */
503 _("Requires someone who is currently allied to "
504 "you to have built %s at some point, and for "
505 "it not to have been rendered obsolete."),
506 improvement_name_translation
507 (preq->source.value.building));
508 } else {
509 cat_snprintf(buf, bufsz,
510 /* TRANS: %s is a wonder */
511 _("Requires someone who is currently allied to "
512 "you to have built %s at some point."),
513 improvement_name_translation
514 (preq->source.value.building));
515 }
516 } else {
517 if (preq->source.kind == VUT_IMPROVEMENT
518 && can_improvement_go_obsolete(preq->source.value.building)) {
519 cat_snprintf(buf, bufsz,
520 /* TRANS: %s is a wonder */
521 _("Prevented if someone currently allied to you "
522 "has ever built %s, unless it would be "
523 "obsolete."),
524 improvement_name_translation
525 (preq->source.value.building));
526 } else {
527 cat_snprintf(buf, bufsz,
528 /* TRANS: %s is a wonder */
529 _("Prevented if someone currently allied to you "
530 "has ever built %s."),
531 improvement_name_translation
532 (preq->source.value.building));
533 }
534 }
535 } else {
536 /* Non-surviving requirement */
537 if (preq->present) {
538 if (preq->source.kind == VUT_IMPROVEMENT
539 && can_improvement_go_obsolete(preq->source.value.building)) {
540 cat_snprintf(buf, bufsz,
541 /* TRANS: %s is a wonder */
542 _("Requires someone allied to you to own %s, "
543 "and for it not to have been rendered "
544 "obsolete."),
545 improvement_name_translation
546 (preq->source.value.building));
547 } else {
548 cat_snprintf(buf, bufsz,
549 /* TRANS: %s is a wonder */
550 _("Requires someone allied to you to own %s."),
551 improvement_name_translation
552 (preq->source.value.building));
553 }
554 } else {
555 if (preq->source.kind == VUT_IMPROVEMENT
556 && can_improvement_go_obsolete(preq->source.value.building)) {
557 cat_snprintf(buf, bufsz,
558 /* TRANS: %s is a wonder */
559 _("Prevented if someone allied to you owns %s, "
560 "unless it is obsolete."),
561 improvement_name_translation
562 (preq->source.value.building));
563 } else {
564 cat_snprintf(buf, bufsz,
565 /* TRANS: %s is a wonder */
566 _("Prevented if someone allied to you owns %s."),
567 improvement_name_translation
568 (preq->source.value.building));
569 }
570 }
571 }
572 return TRUE;
573 }
574 /* Non-wonder alliance-ranged requirements not supported */
575 break;
576 case REQ_RANGE_TEAM:
577 if (is_wonder(preq->source.value.building)) {
578 fc_strlcat(buf, prefix, bufsz);
579 if (preq->survives) {
580 if (preq->present) {
581 if (preq->source.kind == VUT_IMPROVEMENT
582 && can_improvement_go_obsolete(preq->source.value.building)) {
583 cat_snprintf(buf, bufsz,
584 /* TRANS: %s is a wonder */
585 _("Requires someone on your team to have "
586 "built %s at some point, and for it not "
587 "to have been rendered obsolete."),
588 improvement_name_translation
589 (preq->source.value.building));
590 } else {
591 cat_snprintf(buf, bufsz,
592 /* TRANS: %s is a wonder */
593 _("Requires someone on your team to have "
594 "built %s at some point."),
595 improvement_name_translation
596 (preq->source.value.building));
597 }
598 } else {
599 if (preq->source.kind == VUT_IMPROVEMENT
600 && can_improvement_go_obsolete(preq->source.value.building)) {
601 cat_snprintf(buf, bufsz,
602 /* TRANS: %s is a wonder */
603 _("Prevented if someone on your team has ever "
604 "built %s, unless it would be obsolete."),
605 improvement_name_translation
606 (preq->source.value.building));
607 } else {
608 cat_snprintf(buf, bufsz,
609 /* TRANS: %s is a wonder */
610 _("Prevented if someone on your team has ever "
611 "built %s."),
612 improvement_name_translation
613 (preq->source.value.building));
614 }
615 }
616 } else {
617 /* Non-surviving requirement */
618 if (preq->present) {
619 if (preq->source.kind == VUT_IMPROVEMENT
620 && can_improvement_go_obsolete(preq->source.value.building)) {
621 cat_snprintf(buf, bufsz,
622 /* TRANS: %s is a wonder */
623 _("Requires someone on your team to own %s, "
624 "and for it not to have been rendered "
625 "obsolete."),
626 improvement_name_translation
627 (preq->source.value.building));
628 } else {
629 cat_snprintf(buf, bufsz,
630 /* TRANS: %s is a wonder */
631 _("Requires someone on your team to own %s."),
632 improvement_name_translation
633 (preq->source.value.building));
634 }
635 } else {
636 if (preq->source.kind == VUT_IMPROVEMENT
637 && can_improvement_go_obsolete(preq->source.value.building)) {
638 cat_snprintf(buf, bufsz,
639 /* TRANS: %s is a wonder */
640 _("Prevented if someone on your team owns %s, "
641 "unless it is obsolete."),
642 improvement_name_translation
643 (preq->source.value.building));
644 } else {
645 cat_snprintf(buf, bufsz,
646 /* TRANS: %s is a wonder */
647 _("Prevented if someone on your team owns %s."),
648 improvement_name_translation
649 (preq->source.value.building));
650 }
651 }
652 }
653 return TRUE;
654 }
655 /* Non-wonder team-ranged requirements not supported */
656 break;
657 case REQ_RANGE_PLAYER:
658 if (is_wonder(preq->source.value.building)) {
659 fc_strlcat(buf, prefix, bufsz);
660 if (preq->survives) {
661 if (preq->present) {
662 if (preq->source.kind == VUT_IMPROVEMENT
663 && can_improvement_go_obsolete(preq->source.value.building)) {
664 cat_snprintf(buf, bufsz,
665 /* TRANS: %s is a wonder */
666 _("Requires you to have built %s at some point, "
667 "and for it not to have been rendered "
668 "obsolete."),
669 improvement_name_translation
670 (preq->source.value.building));
671 } else {
672 cat_snprintf(buf, bufsz,
673 /* TRANS: %s is a wonder */
674 _("Requires you to have built %s at some point."),
675 improvement_name_translation
676 (preq->source.value.building));
677 }
678 } else {
679 if (preq->source.kind == VUT_IMPROVEMENT
680 && can_improvement_go_obsolete(preq->source.value.building)) {
681 cat_snprintf(buf, bufsz,
682 /* TRANS: %s is a wonder */
683 _("Prevented if you have ever built %s, "
684 "unless it would be obsolete."),
685 improvement_name_translation
686 (preq->source.value.building));
687 } else {
688 cat_snprintf(buf, bufsz,
689 /* TRANS: %s is a wonder */
690 _("Prevented if you have ever built %s."),
691 improvement_name_translation
692 (preq->source.value.building));
693 }
694 }
695 } else {
696 /* Non-surviving requirement */
697 if (preq->present) {
698 if (preq->source.kind == VUT_IMPROVEMENT
699 && can_improvement_go_obsolete(preq->source.value.building)) {
700 cat_snprintf(buf, bufsz,
701 /* TRANS: %s is a wonder */
702 _("Requires you to own %s, which must not "
703 "be obsolete."),
704 improvement_name_translation
705 (preq->source.value.building));
706 } else {
707 cat_snprintf(buf, bufsz,
708 /* TRANS: %s is a wonder */
709 _("Requires you to own %s."),
710 improvement_name_translation
711 (preq->source.value.building));
712 }
713 } else {
714 if (preq->source.kind == VUT_IMPROVEMENT
715 && can_improvement_go_obsolete(preq->source.value.building)) {
716 cat_snprintf(buf, bufsz,
717 /* TRANS: %s is a wonder */
718 _("Prevented if you own %s, unless it is "
719 "obsolete."),
720 improvement_name_translation
721 (preq->source.value.building));
722 } else {
723 cat_snprintf(buf, bufsz,
724 /* TRANS: %s is a wonder */
725 _("Prevented if you own %s."),
726 improvement_name_translation
727 (preq->source.value.building));
728 }
729 }
730 }
731 return TRUE;
732 }
733 /* Non-wonder player-ranged requirements not supported */
734 break;
735 case REQ_RANGE_CONTINENT:
736 if (is_wonder(preq->source.value.building)) {
737 fc_strlcat(buf, prefix, bufsz);
738 if (preq->present) {
739 if (preq->source.kind == VUT_IMPROVEMENT
740 && can_improvement_go_obsolete(preq->source.value.building)) {
741 cat_snprintf(buf, bufsz,
742 /* TRANS: %s is a wonder */
743 _("Requires %s in one of your cities on the same "
744 "continent, and not yet obsolete."),
745 improvement_name_translation
746 (preq->source.value.building));
747 } else {
748 cat_snprintf(buf, bufsz,
749 /* TRANS: %s is a wonder */
750 _("Requires %s in one of your cities on the same "
751 "continent."),
752 improvement_name_translation
753 (preq->source.value.building));
754 }
755 } else {
756 if (preq->source.kind == VUT_IMPROVEMENT
757 && can_improvement_go_obsolete(preq->source.value.building)) {
758 cat_snprintf(buf, bufsz,
759 /* TRANS: %s is a wonder */
760 _("Prevented if %s is in one of your cities on the "
761 "same continent, unless it is obsolete."),
762 improvement_name_translation
763 (preq->source.value.building));
764 } else {
765 cat_snprintf(buf, bufsz,
766 /* TRANS: %s is a wonder */
767 _("Prevented if %s is in one of your cities on the "
768 "same continent."),
769 improvement_name_translation
770 (preq->source.value.building));
771 }
772 }
773 return TRUE;
774 }
775 /* Surviving or non-wonder continent-ranged requirements not supported */
776 break;
777 case REQ_RANGE_TRADE_ROUTE:
778 fc_strlcat(buf, prefix, bufsz);
779 if (preq->present) {
780 if (preq->source.kind == VUT_IMPROVEMENT
781 && can_improvement_go_obsolete(preq->source.value.building)) {
782 /* Should only apply to wonders */
783 cat_snprintf(buf, bufsz,
784 /* TRANS: %s is a building or wonder */
785 _("Requires %s in the city or a trade partner "
786 "(and not yet obsolete)."),
787 improvement_name_translation
788 (preq->source.value.building));
789 } else {
790 cat_snprintf(buf, bufsz,
791 /* TRANS: %s is a building or wonder */
792 _("Requires %s in the city or a trade partner."),
793 improvement_name_translation
794 (preq->source.value.building));
795 }
796 } else {
797 if (preq->source.kind == VUT_IMPROVEMENT
798 && can_improvement_go_obsolete(preq->source.value.building)) {
799 /* Should only apply to wonders */
800 cat_snprintf(buf, bufsz,
801 /* TRANS: %s is a building or wonder */
802 _("Prevented by %s in the city or a trade partner "
803 "(unless it is obsolete)."),
804 improvement_name_translation
805 (preq->source.value.building));
806 } else {
807 cat_snprintf(buf, bufsz,
808 /* TRANS: %s is a building or wonder */
809 _("Prevented by %s in the city or a trade partner."),
810 improvement_name_translation
811 (preq->source.value.building));
812 }
813 }
814 return TRUE;
815 case REQ_RANGE_CITY:
816 fc_strlcat(buf, prefix, bufsz);
817 if (preq->present) {
818 if (preq->source.kind == VUT_IMPROVEMENT
819 && can_improvement_go_obsolete(preq->source.value.building)) {
820 /* Should only apply to wonders */
821 cat_snprintf(buf, bufsz,
822 /* TRANS: %s is a building or wonder */
823 _("Requires %s in the city (and not yet obsolete)."),
824 improvement_name_translation
825 (preq->source.value.building));
826 } else {
827 cat_snprintf(buf, bufsz,
828 /* TRANS: %s is a building or wonder */
829 _("Requires %s in the city."),
830 improvement_name_translation
831 (preq->source.value.building));
832 }
833 } else {
834 if (preq->source.kind == VUT_IMPROVEMENT
835 && can_improvement_go_obsolete(preq->source.value.building)) {
836 /* Should only apply to wonders */
837 cat_snprintf(buf, bufsz,
838 /* TRANS: %s is a building or wonder */
839 _("Prevented by %s in the city (unless it is "
840 "obsolete)."),
841 improvement_name_translation
842 (preq->source.value.building));
843 } else {
844 cat_snprintf(buf, bufsz,
845 /* TRANS: %s is a building or wonder */
846 _("Prevented by %s in the city."),
847 improvement_name_translation
848 (preq->source.value.building));
849 }
850 }
851 return TRUE;
852 case REQ_RANGE_LOCAL:
853 fc_strlcat(buf, prefix, bufsz);
854 if (preq->present) {
855 cat_snprintf(buf, bufsz,
856 _("Only applies to \"%s\" buildings."),
857 improvement_name_translation
858 (preq->source.value.building));
859 } else {
860 cat_snprintf(buf, bufsz,
861 _("Does not apply to \"%s\" buildings."),
862 improvement_name_translation
863 (preq->source.value.building));
864 }
865 return TRUE;
866 case REQ_RANGE_TILE:
867 fc_strlcat(buf, prefix, bufsz);
868 if (preq->present) {
869 cat_snprintf(buf, bufsz,
870 _("Requires \"%s\" building in a city on the tile."),
871 improvement_name_translation
872 (preq->source.value.building));
873 } else {
874 cat_snprintf(buf, bufsz,
875 _("Prevented by \"%s\" building in a city on the tile."),
876 improvement_name_translation
877 (preq->source.value.building));
878 }
879 return TRUE;
880 case REQ_RANGE_CADJACENT:
881 case REQ_RANGE_ADJACENT:
882 case REQ_RANGE_COUNT:
883 /* Not supported. */
884 break;
885 }
886 break;
887
888 case VUT_EXTRA:
889 switch (preq->range) {
890 case REQ_RANGE_LOCAL:
891 fc_strlcat(buf, prefix, bufsz);
892 if (preq->present) {
893 cat_snprintf(buf, bufsz,
894 _("Only applies to \"%s\" extras."),
895 extra_name_translation(preq->source.value.extra));
896 } else {
897 cat_snprintf(buf, bufsz,
898 _("Does not apply to \"%s\" extras."),
899 extra_name_translation(preq->source.value.extra));
900 }
901 return TRUE;
902 case REQ_RANGE_TILE:
903 fc_strlcat(buf, prefix, bufsz);
904 if (preq->present) {
905 cat_snprintf(buf, bufsz,
906 Q_("?extra:Requires %s on the tile."),
907 extra_name_translation(preq->source.value.extra));
908 } else {
909 cat_snprintf(buf, bufsz,
910 Q_("?extra:Prevented by %s on the tile."),
911 extra_name_translation(preq->source.value.extra));
912 }
913 return TRUE;
914 case REQ_RANGE_CADJACENT:
915 fc_strlcat(buf, prefix, bufsz);
916 if (preq->present) {
917 cat_snprintf(buf, bufsz,
918 Q_("?extra:Requires %s on the tile or a cardinally "
919 "adjacent tile."),
920 extra_name_translation(preq->source.value.extra));
921 } else {
922 cat_snprintf(buf, bufsz,
923 Q_("?extra:Prevented by %s on the tile or any cardinally "
924 "adjacent tile."),
925 extra_name_translation(preq->source.value.extra));
926 }
927 return TRUE;
928 case REQ_RANGE_ADJACENT:
929 fc_strlcat(buf, prefix, bufsz);
930 if (preq->present) {
931 cat_snprintf(buf, bufsz,
932 Q_("?extra:Requires %s on the tile or an adjacent "
933 "tile."),
934 extra_name_translation(preq->source.value.extra));
935 } else {
936 cat_snprintf(buf, bufsz,
937 Q_("?extra:Prevented by %s on the tile or any adjacent "
938 "tile."),
939 extra_name_translation(preq->source.value.extra));
940 }
941 return TRUE;
942 case REQ_RANGE_CITY:
943 fc_strlcat(buf, prefix, bufsz);
944 if (preq->present) {
945 cat_snprintf(buf, bufsz,
946 Q_("?extra:Requires %s on a tile within the city "
947 "radius."),
948 extra_name_translation(preq->source.value.extra));
949 } else {
950 cat_snprintf(buf, bufsz,
951 Q_("?extra:Prevented by %s on any tile within the city "
952 "radius."),
953 extra_name_translation(preq->source.value.extra));
954 }
955 return TRUE;
956 case REQ_RANGE_TRADE_ROUTE:
957 fc_strlcat(buf, prefix, bufsz);
958 if (preq->present) {
959 cat_snprintf(buf, bufsz,
960 Q_("?extra:Requires %s on a tile within the city "
961 "radius, or the city radius of a trade partner."),
962 extra_name_translation(preq->source.value.extra));
963 } else {
964 cat_snprintf(buf, bufsz,
965 Q_("?extra:Prevented by %s on any tile within the city "
966 "radius or the city radius of a trade partner."),
967 extra_name_translation(preq->source.value.extra));
968 }
969 return TRUE;
970 case REQ_RANGE_CONTINENT:
971 case REQ_RANGE_PLAYER:
972 case REQ_RANGE_TEAM:
973 case REQ_RANGE_ALLIANCE:
974 case REQ_RANGE_WORLD:
975 case REQ_RANGE_COUNT:
976 /* Not supported. */
977 break;
978 }
979 break;
980
981 case VUT_GOOD:
982 switch (preq->range) {
983 case REQ_RANGE_CITY:
984 fc_strlcat(buf, prefix, bufsz);
985 if (preq->present) {
986 cat_snprintf(buf, bufsz, Q_("?good:Requires import of %s ."),
987 goods_name_translation(preq->source.value.good));
988 } else {
989 cat_snprintf(buf, bufsz, Q_("?goods:Prevented by import of %s."),
990 goods_name_translation(preq->source.value.good));
991 }
992 return TRUE;
993 case REQ_RANGE_LOCAL:
994 case REQ_RANGE_TILE:
995 case REQ_RANGE_CADJACENT:
996 case REQ_RANGE_ADJACENT:
997 case REQ_RANGE_TRADE_ROUTE:
998 case REQ_RANGE_CONTINENT:
999 case REQ_RANGE_PLAYER:
1000 case REQ_RANGE_TEAM:
1001 case REQ_RANGE_ALLIANCE:
1002 case REQ_RANGE_WORLD:
1003 case REQ_RANGE_COUNT:
1004 /* Not supported. */
1005 break;
1006 }
1007 break;
1008
1009 case VUT_TERRAIN:
1010 switch (preq->range) {
1011 case REQ_RANGE_TILE:
1012 fc_strlcat(buf, prefix, bufsz);
1013 if (preq->present) {
1014 cat_snprintf(buf, bufsz, Q_("?terrain:Requires %s on the tile."),
1015 terrain_name_translation(preq->source.value.terrain));
1016 } else {
1017 cat_snprintf(buf, bufsz, Q_("?terrain:Prevented by %s on the tile."),
1018 terrain_name_translation(preq->source.value.terrain));
1019 }
1020 return TRUE;
1021 case REQ_RANGE_CADJACENT:
1022 fc_strlcat(buf, prefix, bufsz);
1023 if (preq->present) {
1024 cat_snprintf(buf, bufsz,
1025 Q_("?terrain:Requires %s on the tile or a cardinally "
1026 "adjacent tile."),
1027 terrain_name_translation(preq->source.value.terrain));
1028 } else {
1029 cat_snprintf(buf, bufsz,
1030 Q_("?terrain:Prevented by %s on the tile or any "
1031 "cardinally adjacent tile."),
1032 terrain_name_translation(preq->source.value.terrain));
1033 }
1034 return TRUE;
1035 case REQ_RANGE_ADJACENT:
1036 fc_strlcat(buf, prefix, bufsz);
1037 if (preq->present) {
1038 cat_snprintf(buf, bufsz,
1039 Q_("?terrain:Requires %s on the tile or an adjacent "
1040 "tile."),
1041 terrain_name_translation(preq->source.value.terrain));
1042 } else {
1043 cat_snprintf(buf, bufsz,
1044 Q_("?terrain:Prevented by %s on the tile or any "
1045 "adjacent tile."),
1046 terrain_name_translation(preq->source.value.terrain));
1047 }
1048 return TRUE;
1049 case REQ_RANGE_CITY:
1050 fc_strlcat(buf, prefix, bufsz);
1051 if (preq->present) {
1052 cat_snprintf(buf, bufsz,
1053 Q_("?terrain:Requires %s on a tile within the city "
1054 "radius."),
1055 terrain_name_translation(preq->source.value.terrain));
1056 } else {
1057 cat_snprintf(buf, bufsz,
1058 Q_("?terrain:Prevented by %s on any tile within the city "
1059 "radius."),
1060 terrain_name_translation(preq->source.value.terrain));
1061 }
1062 return TRUE;
1063 case REQ_RANGE_TRADE_ROUTE:
1064 fc_strlcat(buf, prefix, bufsz);
1065 if (preq->present) {
1066 cat_snprintf(buf, bufsz,
1067 Q_("?terrain:Requires %s on a tile within the city "
1068 "radius, or the city radius of a trade partner."),
1069 terrain_name_translation(preq->source.value.terrain));
1070 } else {
1071 cat_snprintf(buf, bufsz,
1072 Q_("?terrain:Prevented by %s on any tile within the city "
1073 "radius or the city radius of a trade partner."),
1074 terrain_name_translation(preq->source.value.terrain));
1075 }
1076 return TRUE;
1077 case REQ_RANGE_CONTINENT:
1078 case REQ_RANGE_PLAYER:
1079 case REQ_RANGE_TEAM:
1080 case REQ_RANGE_ALLIANCE:
1081 case REQ_RANGE_WORLD:
1082 case REQ_RANGE_LOCAL:
1083 case REQ_RANGE_COUNT:
1084 /* Not supported. */
1085 break;
1086 }
1087 break;
1088
1089 case VUT_NATION:
1090 switch (preq->range) {
1091 case REQ_RANGE_PLAYER:
1092 fc_strlcat(buf, prefix, bufsz);
1093 if (preq->present) {
1094 cat_snprintf(buf, bufsz,
1095 /* TRANS: "... playing as the Swedes." */
1096 _("Requires that you are playing as the %s."),
1097 nation_plural_translation(preq->source.value.nation));
1098 } else {
1099 cat_snprintf(buf, bufsz,
1100 /* TRANS: "... playing as the Turks." */
1101 _("Requires that you are not playing as the %s."),
1102 nation_plural_translation(preq->source.value.nation));
1103 }
1104 return TRUE;
1105 case REQ_RANGE_TEAM:
1106 fc_strlcat(buf, prefix, bufsz);
1107 if (preq->present) {
1108 cat_snprintf(buf, bufsz,
1109 /* TRANS: "... same team as the Indonesians." */
1110 _("Requires that you are on the same team as "
1111 "the %s."),
1112 nation_plural_translation(preq->source.value.nation));
1113 } else {
1114 cat_snprintf(buf, bufsz,
1115 /* TRANS: "... same team as the Greeks." */
1116 _("Requires that you are not on the same team as "
1117 "the %s."),
1118 nation_plural_translation(preq->source.value.nation));
1119 }
1120 return TRUE;
1121 case REQ_RANGE_ALLIANCE:
1122 fc_strlcat(buf, prefix, bufsz);
1123 if (preq->present) {
1124 cat_snprintf(buf, bufsz,
1125 /* TRANS: "... allied with the Koreans." */
1126 _("Requires that you are allied with the %s."),
1127 nation_plural_translation(preq->source.value.nation));
1128 } else {
1129 cat_snprintf(buf, bufsz,
1130 /* TRANS: "... allied with the Danes." */
1131 _("Requires that you are not allied with the %s."),
1132 nation_plural_translation(preq->source.value.nation));
1133 }
1134 return TRUE;
1135 case REQ_RANGE_WORLD:
1136 fc_strlcat(buf, prefix, bufsz);
1137 if (preq->survives) {
1138 if (preq->present) {
1139 cat_snprintf(buf, bufsz,
1140 /* TRANS: "Requires the Apaches to have ..." */
1141 _("Requires the %s to have been in the game."),
1142 nation_plural_translation(preq->source.value.nation));
1143 } else {
1144 cat_snprintf(buf, bufsz,
1145 /* TRANS: "Requires the Celts never to have ..." */
1146 _("Requires the %s never to have been in the "
1147 "game."),
1148 nation_plural_translation(preq->source.value.nation));
1149 }
1150 } else {
1151 if (preq->present) {
1152 cat_snprintf(buf, bufsz,
1153 /* TRANS: "Requires the Belgians in the game." */
1154 _("Requires the %s in the game."),
1155 nation_plural_translation(preq->source.value.nation));
1156 } else {
1157 cat_snprintf(buf, bufsz,
1158 /* TRANS: "Requires that the Russians are not ... */
1159 _("Requires that the %s are not in the game."),
1160 nation_plural_translation(preq->source.value.nation));
1161 }
1162 }
1163 return TRUE;
1164 case REQ_RANGE_LOCAL:
1165 case REQ_RANGE_TILE:
1166 case REQ_RANGE_CADJACENT:
1167 case REQ_RANGE_ADJACENT:
1168 case REQ_RANGE_CITY:
1169 case REQ_RANGE_TRADE_ROUTE:
1170 case REQ_RANGE_CONTINENT:
1171 case REQ_RANGE_COUNT:
1172 /* Not supported. */
1173 break;
1174 }
1175 break;
1176
1177 case VUT_NATIONGROUP:
1178 switch (preq->range) {
1179 case REQ_RANGE_PLAYER:
1180 fc_strlcat(buf, prefix, bufsz);
1181 if (preq->present) {
1182 cat_snprintf(buf, bufsz,
1183 /* TRANS: nation group: "... playing African nation." */
1184 _("Requires that you are playing %s nation."),
1185 nation_group_name_translation(preq->source.value.nationgroup));
1186 } else {
1187 cat_snprintf(buf, bufsz,
1188 /* TRANS: nation group: "... playing Imaginary nation." */
1189 _("Prevented if you are playing %s nation."),
1190 nation_group_name_translation(preq->source.value.nationgroup));
1191 }
1192 return TRUE;
1193 case REQ_RANGE_TEAM:
1194 fc_strlcat(buf, prefix, bufsz);
1195 if (preq->present) {
1196 cat_snprintf(buf, bufsz,
1197 /* TRANS: nation group: "Requires Medieval nation ..." */
1198 _("Requires %s nation on your team."),
1199 nation_group_name_translation(preq->source.value.nationgroup));
1200 } else {
1201 cat_snprintf(buf, bufsz,
1202 /* TRANS: nation group: "Prevented by Medieval nation ..." */
1203 _("Prevented by %s nation on your team."),
1204 nation_group_name_translation(preq->source.value.nationgroup));
1205 }
1206 return TRUE;
1207 case REQ_RANGE_ALLIANCE:
1208 fc_strlcat(buf, prefix, bufsz);
1209 if (preq->present) {
1210 cat_snprintf(buf, bufsz,
1211 /* TRANS: nation group: "Requires Modern nation ..." */
1212 _("Requires %s nation in alliance with you."),
1213 nation_group_name_translation(preq->source.value.nationgroup));
1214 } else {
1215 cat_snprintf(buf, bufsz,
1216 /* TRANS: nation group: "Prevented by Modern nation ..." */
1217 _("Prevented if %s nation is in alliance with you."),
1218 nation_group_name_translation(preq->source.value.nationgroup));
1219 }
1220 return TRUE;
1221 case REQ_RANGE_WORLD:
1222 fc_strlcat(buf, prefix, bufsz);
1223 if (preq->present) {
1224 cat_snprintf(buf, bufsz,
1225 /* TRANS: nation group: "Requires Asian nation ..." */
1226 _("Requires %s nation in the game."),
1227 nation_group_name_translation(preq->source.value.nationgroup));
1228 } else {
1229 cat_snprintf(buf, bufsz,
1230 /* TRANS: nation group: "Prevented by Asian nation ..." */
1231 _("Prevented by %s nation in the game."),
1232 nation_group_name_translation(preq->source.value.nationgroup));
1233 }
1234 return TRUE;
1235 case REQ_RANGE_LOCAL:
1236 case REQ_RANGE_TILE:
1237 case REQ_RANGE_CADJACENT:
1238 case REQ_RANGE_ADJACENT:
1239 case REQ_RANGE_CITY:
1240 case REQ_RANGE_TRADE_ROUTE:
1241 case REQ_RANGE_CONTINENT:
1242 case REQ_RANGE_COUNT:
1243 /* Not supported. */
1244 break;
1245 }
1246 break;
1247
1248 case VUT_STYLE:
1249 if (preq->range != REQ_RANGE_PLAYER) {
1250 break;
1251 }
1252 fc_strlcat(buf, prefix, bufsz);
1253 if (preq->present) {
1254 cat_snprintf(buf, bufsz,
1255 /* TRANS: "Requires that you are playing Asian style
1256 * nation." */
1257 _("Requires that you are playing %s style nation."),
1258 style_name_translation(preq->source.value.style));
1259 } else {
1260 cat_snprintf(buf, bufsz,
1261 /* TRANS: "Requires that you are not playing Classical
1262 * style nation." */
1263 _("Requires that you are not playing %s style nation."),
1264 style_name_translation(preq->source.value.style));
1265 }
1266 return TRUE;
1267
1268 case VUT_NATIONALITY:
1269 switch (preq->range) {
1270 case REQ_RANGE_TRADE_ROUTE:
1271 fc_strlcat(buf, prefix, bufsz);
1272 if (preq->present) {
1273 cat_snprintf(buf, bufsz,
1274 /* TRANS: "Requires at least one Barbarian citizen ..." */
1275 _("Requires at least one %s citizen in the city or a "
1276 "trade partner."),
1277 nation_adjective_translation(preq->source.value.nationality));
1278 } else {
1279 cat_snprintf(buf, bufsz,
1280 /* TRANS: "... no Pirate citizens ..." */
1281 _("Requires that there are no %s citizens in "
1282 "the city or any trade partners."),
1283 nation_adjective_translation(preq->source.value.nationality));
1284 }
1285 return TRUE;
1286 case REQ_RANGE_CITY:
1287 fc_strlcat(buf, prefix, bufsz);
1288 if (preq->present) {
1289 cat_snprintf(buf, bufsz,
1290 /* TRANS: "Requires at least one Barbarian citizen ..." */
1291 _("Requires at least one %s citizen in the city."),
1292 nation_adjective_translation(preq->source.value.nationality));
1293 } else {
1294 cat_snprintf(buf, bufsz,
1295 /* TRANS: "... no Pirate citizens ..." */
1296 _("Requires that there are no %s citizens in "
1297 "the city."),
1298 nation_adjective_translation(preq->source.value.nationality));
1299 }
1300 return TRUE;
1301 case REQ_RANGE_WORLD:
1302 case REQ_RANGE_ALLIANCE:
1303 case REQ_RANGE_TEAM:
1304 case REQ_RANGE_PLAYER:
1305 case REQ_RANGE_LOCAL:
1306 case REQ_RANGE_TILE:
1307 case REQ_RANGE_CADJACENT:
1308 case REQ_RANGE_ADJACENT:
1309 case REQ_RANGE_CONTINENT:
1310 case REQ_RANGE_COUNT:
1311 /* Not supported. */
1312 break;
1313 }
1314 break;
1315
1316 case VUT_ORIGINAL_OWNER:
1317 switch (preq->range) {
1318 case REQ_RANGE_CITY:
1319 fc_strlcat(buf, prefix, bufsz);
1320 if (preq->present) {
1321 cat_snprintf(buf, bufsz,
1322 _("Requires city to be founded by %s."),
1323 nation_adjective_translation(preq->source.value.origowner));
1324 } else {
1325 cat_snprintf(buf, bufsz,
1326 _("Requires that city was not originally owned by %s."),
1327 nation_adjective_translation(preq->source.value.origowner));
1328 }
1329 return TRUE;
1330 case REQ_RANGE_TRADE_ROUTE:
1331 case REQ_RANGE_WORLD:
1332 case REQ_RANGE_ALLIANCE:
1333 case REQ_RANGE_TEAM:
1334 case REQ_RANGE_PLAYER:
1335 case REQ_RANGE_LOCAL:
1336 case REQ_RANGE_TILE:
1337 case REQ_RANGE_CADJACENT:
1338 case REQ_RANGE_ADJACENT:
1339 case REQ_RANGE_CONTINENT:
1340 case REQ_RANGE_COUNT:
1341 /* Not supported. */
1342 break;
1343 }
1344 break;
1345
1346 case VUT_DIPLREL:
1347 switch (preq->range) {
1348 case REQ_RANGE_PLAYER:
1349 fc_strlcat(buf, prefix, bufsz);
1350 if (preq->present) {
1351 cat_snprintf(buf, bufsz,
1352 /* TRANS: in this and following strings, '%s' can be one
1353 * of a wide range of relationships; e.g., 'Peace',
1354 * 'Never met', 'Foreign', 'Hosts embassy',
1355 * 'Provided Casus Belli' */
1356 _("Requires that you have the relationship '%s' with at "
1357 "least one other living player."),
1358 diplrel_name_translation(preq->source.value.diplrel));
1359 } else {
1360 cat_snprintf(buf, bufsz,
1361 _("Requires that you do not have the relationship '%s' "
1362 "with any living player."),
1363 diplrel_name_translation(preq->source.value.diplrel));
1364 }
1365 return TRUE;
1366 case REQ_RANGE_TEAM:
1367 fc_strlcat(buf, prefix, bufsz);
1368 if (preq->present) {
1369 cat_snprintf(buf, bufsz,
1370 _("Requires that somebody on your team has the "
1371 "relationship '%s' with at least one other living "
1372 "player."),
1373 diplrel_name_translation(preq->source.value.diplrel));
1374 } else {
1375 cat_snprintf(buf, bufsz,
1376 _("Requires that nobody on your team has the "
1377 "relationship '%s' with any living player."),
1378 diplrel_name_translation(preq->source.value.diplrel));
1379 }
1380 return TRUE;
1381 case REQ_RANGE_ALLIANCE:
1382 fc_strlcat(buf, prefix, bufsz);
1383 if (preq->present) {
1384 cat_snprintf(buf, bufsz,
1385 _("Requires that somebody in your alliance has the "
1386 "relationship '%s' with at least one other living "
1387 "player."),
1388 diplrel_name_translation(preq->source.value.diplrel));
1389 } else {
1390 cat_snprintf(buf, bufsz,
1391 _("Requires that nobody in your alliance has the "
1392 "relationship '%s' with any living player."),
1393 diplrel_name_translation(preq->source.value.diplrel));
1394 }
1395 return TRUE;
1396 case REQ_RANGE_WORLD:
1397 fc_strlcat(buf, prefix, bufsz);
1398 if (preq->present) {
1399 cat_snprintf(buf, bufsz,
1400 _("Requires the relationship '%s' between two living "
1401 "players."),
1402 diplrel_name_translation(preq->source.value.diplrel));
1403 } else {
1404 cat_snprintf(buf, bufsz,
1405 _("Requires that no two living players have the "
1406 "relationship '%s'."),
1407 diplrel_name_translation(preq->source.value.diplrel));
1408 }
1409 return TRUE;
1410 case REQ_RANGE_LOCAL:
1411 fc_strlcat(buf, prefix, bufsz);
1412 if (preq->present) {
1413 cat_snprintf(buf, bufsz,
1414 _("Requires that you have the relationship '%s' with the "
1415 "other player."),
1416 diplrel_name_translation(preq->source.value.diplrel));
1417 } else {
1418 cat_snprintf(buf, bufsz,
1419 _("Requires that you do not have the relationship '%s' "
1420 "with the other player."),
1421 diplrel_name_translation(preq->source.value.diplrel));
1422 }
1423 return TRUE;
1424 case REQ_RANGE_TILE:
1425 case REQ_RANGE_CADJACENT:
1426 case REQ_RANGE_ADJACENT:
1427 case REQ_RANGE_CITY:
1428 case REQ_RANGE_TRADE_ROUTE:
1429 case REQ_RANGE_CONTINENT:
1430 case REQ_RANGE_COUNT:
1431 /* Not supported. */
1432 break;
1433 }
1434 break;
1435
1436 case VUT_DIPLREL_TILE:
1437 switch (preq->range) {
1438 case REQ_RANGE_PLAYER:
1439 fc_strlcat(buf, prefix, bufsz);
1440 if (preq->present) {
1441 cat_snprintf(buf, bufsz,
1442 /* TRANS: in this and following strings, '%s' can be one
1443 * of a wide range of relationships; e.g., 'Peace',
1444 * 'Never met', 'Foreign', 'Hosts embassy',
1445 * 'Provided Casus Belli' */
1446 _("Requires that the tile owner has the relationship"
1447 " '%s' with at least one other living player."),
1448 diplrel_name_translation(preq->source.value.diplrel));
1449 } else {
1450 cat_snprintf(buf, bufsz,
1451 _("Requires that the tile owner does not have the"
1452 " relationship '%s' with any living player."),
1453 diplrel_name_translation(preq->source.value.diplrel));
1454 }
1455 return TRUE;
1456 case REQ_RANGE_TEAM:
1457 fc_strlcat(buf, prefix, bufsz);
1458 if (preq->present) {
1459 cat_snprintf(buf, bufsz,
1460 _("Requires that somebody on the tile owner's team"
1461 " has the relationship '%s' with at least one other"
1462 " living player."),
1463 diplrel_name_translation(preq->source.value.diplrel));
1464 } else {
1465 cat_snprintf(buf, bufsz,
1466 _("Requires that nobody on the tile owner's team has"
1467 " the relationship '%s' with any living player."),
1468 diplrel_name_translation(preq->source.value.diplrel));
1469 }
1470 return TRUE;
1471 case REQ_RANGE_ALLIANCE:
1472 fc_strlcat(buf, prefix, bufsz);
1473 if (preq->present) {
1474 cat_snprintf(buf, bufsz,
1475 _("Requires that somebody in the tile owner's alliance"
1476 " has the relationship '%s' with at least one other "
1477 "living player."),
1478 diplrel_name_translation(preq->source.value.diplrel));
1479 } else {
1480 cat_snprintf(buf, bufsz,
1481 _("Requires that nobody in the tile owner's alliance "
1482 "has the relationship '%s' with any living player."),
1483 diplrel_name_translation(preq->source.value.diplrel));
1484 }
1485 return TRUE;
1486 case REQ_RANGE_LOCAL:
1487 fc_strlcat(buf, prefix, bufsz);
1488 if (preq->present) {
1489 cat_snprintf(buf, bufsz,
1490 _("Requires that you have the relationship '%s' with"
1491 " the tile owner."),
1492 diplrel_name_translation(preq->source.value.diplrel));
1493 } else {
1494 cat_snprintf(buf, bufsz,
1495 _("Requires that you do not have the relationship '%s'"
1496 " with the tile owner."),
1497 diplrel_name_translation(preq->source.value.diplrel));
1498 }
1499 return TRUE;
1500 case REQ_RANGE_TILE:
1501 case REQ_RANGE_CADJACENT:
1502 case REQ_RANGE_ADJACENT:
1503 case REQ_RANGE_CITY:
1504 case REQ_RANGE_TRADE_ROUTE:
1505 case REQ_RANGE_CONTINENT:
1506 case REQ_RANGE_WORLD:
1507 case REQ_RANGE_COUNT:
1508 /* Not supported. */
1509 break;
1510 }
1511 break;
1512
1513 case VUT_DIPLREL_TILE_O:
1514 switch (preq->range) {
1515 case REQ_RANGE_LOCAL:
1516 fc_strlcat(buf, prefix, bufsz);
1517 if (preq->present) {
1518 cat_snprintf(buf, bufsz,
1519 _("Requires that the tile owner has the relationship"
1520 " '%s' with the other player."),
1521 diplrel_name_translation(preq->source.value.diplrel));
1522 } else {
1523 cat_snprintf(buf, bufsz,
1524 _("Requires that the tile owner does not have the"
1525 " relationship '%s' with the other player."),
1526 diplrel_name_translation(preq->source.value.diplrel));
1527 }
1528 return TRUE;
1529 case REQ_RANGE_TILE:
1530 case REQ_RANGE_CADJACENT:
1531 case REQ_RANGE_ADJACENT:
1532 case REQ_RANGE_CITY:
1533 case REQ_RANGE_TRADE_ROUTE:
1534 case REQ_RANGE_CONTINENT:
1535 case REQ_RANGE_PLAYER:
1536 case REQ_RANGE_TEAM:
1537 case REQ_RANGE_ALLIANCE:
1538 case REQ_RANGE_WORLD:
1539 case REQ_RANGE_COUNT:
1540 /* Not supported. */
1541 break;
1542 }
1543 break;
1544
1545 case VUT_DIPLREL_UNITANY:
1546 switch (preq->range) {
1547 case REQ_RANGE_PLAYER:
1548 fc_strlcat(buf, prefix, bufsz);
1549 if (preq->present) {
1550 cat_snprintf(buf, bufsz,
1551 /* TRANS: in this and following strings, '%s' can be one
1552 * of a wide range of relationships; e.g., 'Peace',
1553 * 'Never met', 'Foreign', 'Hosts embassy',
1554 * 'Provided Casus Belli' */
1555 _("Requires that the tile has at least one unit whose "
1556 "owner has the relationship "
1557 "'%s' with at least one other living player."),
1558 diplrel_name_translation(preq->source.value.diplrel));
1559 } else {
1560 cat_snprintf(buf, bufsz,
1561 _("Requires that no unit at the tile is owned by a player "
1562 "who has the relationship '%s' with any living player."),
1563 diplrel_name_translation(preq->source.value.diplrel));
1564 }
1565 return TRUE;
1566 case REQ_RANGE_TEAM:
1567 fc_strlcat(buf, prefix, bufsz);
1568 if (preq->present) {
1569 cat_snprintf(buf, bufsz,
1570 _("Requires that the tile has at least one unit whose "
1571 "owner is on a team where a member "
1572 "has the relationship '%s' with at least one other "
1573 "living player."),
1574 diplrel_name_translation(preq->source.value.diplrel));
1575 } else {
1576 cat_snprintf(buf, bufsz,
1577 _("Requires that no unit at the tile is owned by a player "
1578 "who is on a team where a member "
1579 "has the relationship '%s' with at least one other "
1580 "living player."),
1581 diplrel_name_translation(preq->source.value.diplrel));
1582 }
1583 return TRUE;
1584 case REQ_RANGE_ALLIANCE:
1585 fc_strlcat(buf, prefix, bufsz);
1586 if (preq->present) {
1587 cat_snprintf(buf, bufsz,
1588 _("Requires that the tile has at least one unit whose "
1589 "owner is allied to someone that "
1590 "has the relationship '%s' with at least one other "
1591 "living player."),
1592 diplrel_name_translation(preq->source.value.diplrel));
1593 } else {
1594 cat_snprintf(buf, bufsz,
1595 _("Requires that no unit at the tile is owned by a player "
1596 "allied to someone that "
1597 "has the relationship '%s' with any living player."),
1598 diplrel_name_translation(preq->source.value.diplrel));
1599 }
1600 return TRUE;
1601 case REQ_RANGE_LOCAL:
1602 fc_strlcat(buf, prefix, bufsz);
1603 if (preq->present) {
1604 cat_snprintf(buf, bufsz,
1605 _("Requires that you have the relationship '%s' with "
1606 "the owner of at least one unit at the tile."),
1607 diplrel_name_translation(preq->source.value.diplrel));
1608 } else {
1609 cat_snprintf(buf, bufsz,
1610 _("Requires that you do not have the relationship '%s' "
1611 "with the owner of any unit at the tile."),
1612 diplrel_name_translation(preq->source.value.diplrel));
1613 }
1614 return TRUE;
1615 case REQ_RANGE_TILE:
1616 case REQ_RANGE_CADJACENT:
1617 case REQ_RANGE_ADJACENT:
1618 case REQ_RANGE_CITY:
1619 case REQ_RANGE_TRADE_ROUTE:
1620 case REQ_RANGE_CONTINENT:
1621 case REQ_RANGE_WORLD:
1622 case REQ_RANGE_COUNT:
1623 /* Not supported. */
1624 break;
1625 }
1626 break;
1627
1628 case VUT_DIPLREL_UNITANY_O:
1629 switch (preq->range) {
1630 case REQ_RANGE_LOCAL:
1631 fc_strlcat(buf, prefix, bufsz);
1632 if (preq->present) {
1633 cat_snprintf(buf, bufsz,
1634 _("Requires that the tile has at least one unit whose "
1635 "owner has the relationship '%s' with the other player."),
1636 diplrel_name_translation(preq->source.value.diplrel));
1637 } else {
1638 cat_snprintf(buf, bufsz,
1639 _("Requires that no unit at the tile is owned by a player "
1640 "who has the relationship '%s' with the other player."),
1641 diplrel_name_translation(preq->source.value.diplrel));
1642 }
1643 return TRUE;
1644 case REQ_RANGE_TILE:
1645 case REQ_RANGE_CADJACENT:
1646 case REQ_RANGE_ADJACENT:
1647 case REQ_RANGE_CITY:
1648 case REQ_RANGE_TRADE_ROUTE:
1649 case REQ_RANGE_CONTINENT:
1650 case REQ_RANGE_PLAYER:
1651 case REQ_RANGE_TEAM:
1652 case REQ_RANGE_ALLIANCE:
1653 case REQ_RANGE_WORLD:
1654 case REQ_RANGE_COUNT:
1655 /* Not supported. */
1656 break;
1657 }
1658 break;
1659
1660 case VUT_UTYPE:
1661 switch (preq->range) {
1662 case REQ_RANGE_LOCAL:
1663 fc_strlcat(buf, prefix, bufsz);
1664 if (preq->present) {
1665 /* TRANS: %s is a single kind of unit (e.g., "Settlers"). */
1666 cat_snprintf(buf, bufsz, Q_("?unit:Requires %s."),
1667 utype_name_translation(preq->source.value.utype));
1668 } else {
1669 /* TRANS: %s is a single kind of unit (e.g., "Settlers"). */
1670 cat_snprintf(buf, bufsz, Q_("?unit:Does not apply to %s."),
1671 utype_name_translation(preq->source.value.utype));
1672 }
1673 return TRUE;
1674 case REQ_RANGE_TILE:
1675 case REQ_RANGE_CADJACENT:
1676 case REQ_RANGE_ADJACENT:
1677 case REQ_RANGE_CITY:
1678 case REQ_RANGE_TRADE_ROUTE:
1679 case REQ_RANGE_CONTINENT:
1680 case REQ_RANGE_PLAYER:
1681 case REQ_RANGE_TEAM:
1682 case REQ_RANGE_ALLIANCE:
1683 case REQ_RANGE_WORLD:
1684 case REQ_RANGE_COUNT:
1685 /* Not supported. */
1686 break;
1687 }
1688 break;
1689
1690 case VUT_UTFLAG:
1691 switch (preq->range) {
1692 case REQ_RANGE_LOCAL:
1693 {
1694 struct astring astr = ASTRING_INIT;
1695
1696 /* Unit type flags mean nothing to users. Explicitly list the unit
1697 * types with those flags. */
1698 if (role_units_translations(&astr, preq->source.value.unitflag,
1699 TRUE)) {
1700 fc_strlcat(buf, prefix, bufsz);
1701 if (preq->present) {
1702 /* TRANS: %s is a list of unit types separated by "or". */
1703 cat_snprintf(buf, bufsz, Q_("?ulist:Requires %s."),
1704 astr_str(&astr));
1705 } else {
1706 /* TRANS: %s is a list of unit types separated by "or". */
1707 cat_snprintf(buf, bufsz, Q_("?ulist:Does not apply to %s."),
1708 astr_str(&astr));
1709 }
1710 astr_free(&astr);
1711 return TRUE;
1712 }
1713 }
1714 break;
1715 case REQ_RANGE_TILE:
1716 case REQ_RANGE_CADJACENT:
1717 case REQ_RANGE_ADJACENT:
1718 case REQ_RANGE_CITY:
1719 case REQ_RANGE_TRADE_ROUTE:
1720 case REQ_RANGE_CONTINENT:
1721 case REQ_RANGE_PLAYER:
1722 case REQ_RANGE_TEAM:
1723 case REQ_RANGE_ALLIANCE:
1724 case REQ_RANGE_WORLD:
1725 case REQ_RANGE_COUNT:
1726 /* Not supported. */
1727 break;
1728 }
1729 break;
1730
1731 case VUT_UCLASS:
1732 switch (preq->range) {
1733 case REQ_RANGE_LOCAL:
1734 fc_strlcat(buf, prefix, bufsz);
1735 if (preq->present) {
1736 /* TRANS: %s is a single unit class (e.g., "Air"). */
1737 cat_snprintf(buf, bufsz, Q_("?uclass:Requires %s units."),
1738 uclass_name_translation(preq->source.value.uclass));
1739 } else {
1740 /* TRANS: %s is a single unit class (e.g., "Air"). */
1741 cat_snprintf(buf, bufsz, Q_("?uclass:Does not apply to %s units."),
1742 uclass_name_translation(preq->source.value.uclass));
1743 }
1744 return TRUE;
1745 case REQ_RANGE_TILE:
1746 case REQ_RANGE_CADJACENT:
1747 case REQ_RANGE_ADJACENT:
1748 case REQ_RANGE_CITY:
1749 case REQ_RANGE_TRADE_ROUTE:
1750 case REQ_RANGE_CONTINENT:
1751 case REQ_RANGE_PLAYER:
1752 case REQ_RANGE_TEAM:
1753 case REQ_RANGE_ALLIANCE:
1754 case REQ_RANGE_WORLD:
1755 case REQ_RANGE_COUNT:
1756 /* Not supported. */
1757 break;
1758 }
1759 break;
1760
1761 case VUT_UCFLAG:
1762 {
1763 const char *classes[uclass_count()];
1764 int i = 0;
1765 bool done = FALSE;
1766 struct astring list = ASTRING_INIT;
1767
1768 unit_class_iterate(uclass) {
1769 if (uclass_has_flag(uclass, preq->source.value.unitclassflag)) {
1770 classes[i++] = uclass_name_translation(uclass);
1771 }
1772 } unit_class_iterate_end;
1773 astr_build_or_list(&list, classes, i);
1774
1775 switch (preq->range) {
1776 case REQ_RANGE_LOCAL:
1777 fc_strlcat(buf, prefix, bufsz);
1778 if (preq->present) {
1779 /* TRANS: %s is a list of unit classes separated by "or". */
1780 cat_snprintf(buf, bufsz, Q_("?uclasslist:Requires %s units."),
1781 astr_str(&list));
1782 } else {
1783 /* TRANS: %s is a list of unit classes separated by "or". */
1784 cat_snprintf(buf, bufsz, Q_("?uclasslist:Does not apply to "
1785 "%s units."),
1786 astr_str(&list));
1787 }
1788 done = TRUE;
1789 break;
1790 case REQ_RANGE_TILE:
1791 case REQ_RANGE_CADJACENT:
1792 case REQ_RANGE_ADJACENT:
1793 case REQ_RANGE_CITY:
1794 case REQ_RANGE_TRADE_ROUTE:
1795 case REQ_RANGE_CONTINENT:
1796 case REQ_RANGE_PLAYER:
1797 case REQ_RANGE_TEAM:
1798 case REQ_RANGE_ALLIANCE:
1799 case REQ_RANGE_WORLD:
1800 case REQ_RANGE_COUNT:
1801 /* Not supported. */
1802 break;
1803 }
1804 astr_free(&list);
1805 if (done) {
1806 return TRUE;
1807 }
1808 }
1809 break;
1810
1811 case VUT_UNITSTATE:
1812 {
1813 switch (preq->range) {
1814 case REQ_RANGE_LOCAL:
1815 switch (preq->source.value.unit_state) {
1816 case USP_TRANSPORTED:
1817 fc_strlcat(buf, prefix, bufsz);
1818 if (preq->present) {
1819 cat_snprintf(buf, bufsz,
1820 _("Requires that the unit is transported."));
1821 } else {
1822 cat_snprintf(buf, bufsz,
1823 _("Requires that the unit isn't transported."));
1824 }
1825 return TRUE;
1826 case USP_LIVABLE_TILE:
1827 fc_strlcat(buf, prefix, bufsz);
1828 if (preq->present) {
1829 cat_snprintf(buf, bufsz,
1830 _("Requires that the unit is on livable tile."));
1831 } else {
1832 cat_snprintf(buf, bufsz,
1833 _("Requires that the unit isn't on livable tile."));
1834 }
1835 return TRUE;
1836 case USP_TRANSPORTING:
1837 fc_strlcat(buf, prefix, bufsz);
1838 if (preq->present) {
1839 cat_snprintf(buf, bufsz,
1840 _("Requires that the unit does transport one or "
1841 "more cargo units."));
1842 } else {
1843 cat_snprintf(buf, bufsz,
1844 _("Requires that the unit doesn't transport "
1845 "any cargo units."));
1846 }
1847 return TRUE;
1848 case USP_HAS_HOME_CITY:
1849 fc_strlcat(buf, prefix, bufsz);
1850 if (preq->present) {
1851 cat_snprintf(buf, bufsz,
1852 _("Requires that the unit has a home city."));
1853 } else {
1854 cat_snprintf(buf, bufsz,
1855 _("Requires that the unit is homeless."));
1856 }
1857 return TRUE;
1858 case USP_NATIVE_TILE:
1859 fc_strlcat(buf, prefix, bufsz);
1860 if (preq->present) {
1861 cat_snprintf(buf, bufsz,
1862 _("Requires that the unit is on native tile."));
1863 } else {
1864 cat_snprintf(buf, bufsz,
1865 _("Requires that the unit isn't on native tile."));
1866 }
1867 return TRUE;
1868 case USP_NATIVE_EXTRA:
1869 fc_strlcat(buf, prefix, bufsz);
1870 if (preq->present) {
1871 cat_snprintf(buf, bufsz,
1872 _("Requires that the unit is in a native extra."));
1873 } else {
1874 cat_snprintf(buf, bufsz,
1875 _("Requires that the unit isn't in a native extra."));
1876 }
1877 return TRUE;
1878 case USP_MOVED_THIS_TURN:
1879 fc_strlcat(buf, prefix, bufsz);
1880 if (preq->present) {
1881 cat_snprintf(buf, bufsz,
1882 _("Requires that the unit has moved this turn."));
1883 } else {
1884 cat_snprintf(buf, bufsz,
1885 _("Requires that the unit hasn't moved this turn."));
1886 }
1887 return TRUE;
1888 case USP_COUNT:
1889 fc_assert_msg(preq->source.value.unit_state != USP_COUNT,
1890 "Invalid unit state property.");
1891 }
1892 break;
1893 case REQ_RANGE_TILE:
1894 case REQ_RANGE_CADJACENT:
1895 case REQ_RANGE_ADJACENT:
1896 case REQ_RANGE_CITY:
1897 case REQ_RANGE_TRADE_ROUTE:
1898 case REQ_RANGE_CONTINENT:
1899 case REQ_RANGE_PLAYER:
1900 case REQ_RANGE_TEAM:
1901 case REQ_RANGE_ALLIANCE:
1902 case REQ_RANGE_WORLD:
1903 case REQ_RANGE_COUNT:
1904 /* Not supported. */
1905 break;
1906 }
1907 }
1908 break;
1909
1910 case VUT_ACTIVITY:
1911 {
1912 switch (preq->range) {
1913 case REQ_RANGE_LOCAL:
1914 fc_strlcat(buf, prefix, bufsz);
1915 if (preq->present) {
1916 cat_snprintf(buf, bufsz,
1917 _("Requires that the unit is performing activity %s."),
1918 Q_(unit_activity_name(preq->source.value.activity)));
1919 } else {
1920 cat_snprintf(buf, bufsz,
1921 _("Requires that the unit is not performing activity %s."),
1922 Q_(unit_activity_name(preq->source.value.activity)));
1923 }
1924 return TRUE;
1925 case REQ_RANGE_TILE:
1926 case REQ_RANGE_CADJACENT:
1927 case REQ_RANGE_ADJACENT:
1928 case REQ_RANGE_CITY:
1929 case REQ_RANGE_TRADE_ROUTE:
1930 case REQ_RANGE_CONTINENT:
1931 case REQ_RANGE_PLAYER:
1932 case REQ_RANGE_TEAM:
1933 case REQ_RANGE_ALLIANCE:
1934 case REQ_RANGE_WORLD:
1935 case REQ_RANGE_COUNT:
1936 /* Not supported. */
1937 break;
1938 }
1939 }
1940 break;
1941
1942 case VUT_MINMOVES:
1943 {
1944 switch (preq->range) {
1945 case REQ_RANGE_LOCAL:
1946 fc_strlcat(buf, prefix, bufsz);
1947 if (preq->present) {
1948 cat_snprintf(buf, bufsz,
1949 /* TRANS: %s is numeric move points; it may have a
1950 * fractional part ("1 1/3 MP"). */
1951 _("Requires that the unit has at least %s MP left."),
1952 move_points_text(preq->source.value.minmoves, TRUE));
1953 } else {
1954 cat_snprintf(buf, bufsz,
1955 /* TRANS: %s is numeric move points; it may have a
1956 * fractional part ("1 1/3 MP"). */
1957 _("Requires that the unit has less than %s MP left."),
1958 move_points_text(preq->source.value.minmoves, TRUE));
1959 }
1960 return TRUE;
1961 case REQ_RANGE_TILE:
1962 case REQ_RANGE_CADJACENT:
1963 case REQ_RANGE_ADJACENT:
1964 case REQ_RANGE_CITY:
1965 case REQ_RANGE_TRADE_ROUTE:
1966 case REQ_RANGE_CONTINENT:
1967 case REQ_RANGE_PLAYER:
1968 case REQ_RANGE_TEAM:
1969 case REQ_RANGE_ALLIANCE:
1970 case REQ_RANGE_WORLD:
1971 case REQ_RANGE_COUNT:
1972 /* Not supported. */
1973 break;
1974 }
1975 }
1976 break;
1977
1978 case VUT_MINVETERAN:
1979 if (preq->range != REQ_RANGE_LOCAL) {
1980 break;
1981 }
1982 /* FIXME: this would be better with veteran level names, but that's
1983 * potentially unit type dependent. */
1984 fc_strlcat(buf, prefix, bufsz);
1985 if (preq->present) {
1986 cat_snprintf(buf, bufsz,
1987 PL_("Requires a unit with at least %d veteran level.",
1988 "Requires a unit with at least %d veteran levels.",
1989 preq->source.value.minveteran),
1990 preq->source.value.minveteran);
1991 } else {
1992 cat_snprintf(buf, bufsz,
1993 PL_("Requires a unit with fewer than %d veteran level.",
1994 "Requires a unit with fewer than %d veteran levels.",
1995 preq->source.value.minveteran),
1996 preq->source.value.minveteran);
1997 }
1998 return TRUE;
1999
2000 case VUT_MINHP:
2001 if (preq->range != REQ_RANGE_LOCAL) {
2002 break;
2003 }
2004
2005 fc_strlcat(buf, prefix, bufsz);
2006 if (preq->present) {
2007 cat_snprintf(buf, bufsz,
2008 PL_("Requires a unit with at least %d hit point left.",
2009 "Requires a unit with at least %d hit points left.",
2010 preq->source.value.min_hit_points),
2011 preq->source.value.min_hit_points);
2012 } else {
2013 cat_snprintf(buf, bufsz,
2014 PL_("Requires a unit with fewer than %d hit point "
2015 "left.",
2016 "Requires a unit with fewer than %d hit points "
2017 "left.",
2018 preq->source.value.min_hit_points),
2019 preq->source.value.min_hit_points);
2020 }
2021 return TRUE;
2022
2023 case VUT_OTYPE:
2024 if (preq->range != REQ_RANGE_LOCAL) {
2025 break;
2026 }
2027 fc_strlcat(buf, prefix, bufsz);
2028 if (preq->present) {
2029 /* TRANS: "Applies only to Food." */
2030 cat_snprintf(buf, bufsz, Q_("?output:Applies only to %s."),
2031 get_output_name(preq->source.value.outputtype));
2032 } else {
2033 /* TRANS: "Does not apply to Food." */
2034 cat_snprintf(buf, bufsz, Q_("?output:Does not apply to %s."),
2035 get_output_name(preq->source.value.outputtype));
2036 }
2037 return TRUE;
2038
2039 case VUT_SPECIALIST:
2040 if (preq->range != REQ_RANGE_LOCAL) {
2041 break;
2042 }
2043 fc_strlcat(buf, prefix, bufsz);
2044 if (preq->present) {
2045 /* TRANS: "Applies only to Scientists." */
2046 cat_snprintf(buf, bufsz, Q_("?specialist:Applies only to %s."),
2047 specialist_plural_translation(preq->source.value.specialist));
2048 } else {
2049 /* TRANS: "Does not apply to Scientists." */
2050 cat_snprintf(buf, bufsz, Q_("?specialist:Does not apply to %s."),
2051 specialist_plural_translation(preq->source.value.specialist));
2052 }
2053 return TRUE;
2054
2055 case VUT_MINSIZE:
2056 switch (preq->range) {
2057 case REQ_RANGE_TRADE_ROUTE:
2058 fc_strlcat(buf, prefix, bufsz);
2059 if (preq->present) {
2060 cat_snprintf(buf, bufsz,
2061 PL_("Requires a minimum city size of %d for this "
2062 "city or a trade partner.",
2063 "Requires a minimum city size of %d for this "
2064 "city or a trade partner.",
2065 preq->source.value.minsize),
2066 preq->source.value.minsize);
2067 } else {
2068 cat_snprintf(buf, bufsz,
2069 PL_("Requires the city size to be less than %d "
2070 "for this city and all trade partners.",
2071 "Requires the city size to be less than %d "
2072 "for this city and all trade partners.",
2073 preq->source.value.minsize),
2074 preq->source.value.minsize);
2075 }
2076 return TRUE;
2077 case REQ_RANGE_CITY:
2078 fc_strlcat(buf, prefix, bufsz);
2079 if (preq->present) {
2080 cat_snprintf(buf, bufsz,
2081 PL_("Requires a minimum city size of %d.",
2082 "Requires a minimum city size of %d.",
2083 preq->source.value.minsize),
2084 preq->source.value.minsize);
2085 } else {
2086 cat_snprintf(buf, bufsz,
2087 PL_("Requires the city size to be less than %d.",
2088 "Requires the city size to be less than %d.",
2089 preq->source.value.minsize),
2090 preq->source.value.minsize);
2091 }
2092 return TRUE;
2093 case REQ_RANGE_LOCAL:
2094 case REQ_RANGE_TILE:
2095 case REQ_RANGE_CADJACENT:
2096 case REQ_RANGE_ADJACENT:
2097 case REQ_RANGE_CONTINENT:
2098 case REQ_RANGE_PLAYER:
2099 case REQ_RANGE_TEAM:
2100 case REQ_RANGE_ALLIANCE:
2101 case REQ_RANGE_WORLD:
2102 case REQ_RANGE_COUNT:
2103 /* Not supported. */
2104 break;
2105 }
2106 break;
2107
2108 case VUT_MINCULTURE:
2109 switch (preq->range) {
2110 case REQ_RANGE_CITY:
2111 fc_strlcat(buf, prefix, bufsz);
2112 if (preq->present) {
2113 cat_snprintf(buf, bufsz,
2114 PL_("Requires a minimum culture of %d in the city.",
2115 "Requires a minimum culture of %d in the city.",
2116 preq->source.value.minculture),
2117 preq->source.value.minculture);
2118 } else {
2119 cat_snprintf(buf, bufsz,
2120 PL_("Requires the culture in the city to be less "
2121 "than %d.",
2122 "Requires the culture in the city to be less "
2123 "than %d.",
2124 preq->source.value.minculture),
2125 preq->source.value.minculture);
2126 }
2127 return TRUE;
2128 case REQ_RANGE_TRADE_ROUTE:
2129 fc_strlcat(buf, prefix, bufsz);
2130 if (preq->present) {
2131 cat_snprintf(buf, bufsz,
2132 PL_("Requires a minimum culture of %d in this city or "
2133 "a trade partner.",
2134 "Requires a minimum culture of %d in this city or "
2135 "a trade partner.",
2136 preq->source.value.minculture),
2137 preq->source.value.minculture);
2138 } else {
2139 cat_snprintf(buf, bufsz,
2140 PL_("Requires the culture in this city and all trade "
2141 "partners to be less than %d.",
2142 "Requires the culture in this city and all trade "
2143 "partners to be less than %d.",
2144 preq->source.value.minculture),
2145 preq->source.value.minculture);
2146 }
2147 return TRUE;
2148 case REQ_RANGE_PLAYER:
2149 fc_strlcat(buf, prefix, bufsz);
2150 if (preq->present) {
2151 cat_snprintf(buf, bufsz,
2152 PL_("Requires your nation to have culture "
2153 "of at least %d.",
2154 "Requires your nation to have culture "
2155 "of at least %d.",
2156 preq->source.value.minculture),
2157 preq->source.value.minculture);
2158 } else {
2159 cat_snprintf(buf, bufsz,
2160 PL_("Prevented if your nation has culture of "
2161 "%d or more.",
2162 "Prevented if your nation has culture of "
2163 "%d or more.",
2164 preq->source.value.minculture),
2165 preq->source.value.minculture);
2166 }
2167 return TRUE;
2168 case REQ_RANGE_TEAM:
2169 fc_strlcat(buf, prefix, bufsz);
2170 if (preq->present) {
2171 cat_snprintf(buf, bufsz,
2172 PL_("Requires someone on your team to have culture of "
2173 "at least %d.",
2174 "Requires someone on your team to have culture of "
2175 "at least %d.",
2176 preq->source.value.minculture),
2177 preq->source.value.minculture);
2178 } else {
2179 cat_snprintf(buf, bufsz,
2180 PL_("Prevented if anyone on your team has culture of "
2181 "%d or more.",
2182 "Prevented if anyone on your team has culture of "
2183 "%d or more.",
2184 preq->source.value.minculture),
2185 preq->source.value.minculture);
2186 }
2187 return TRUE;
2188 case REQ_RANGE_ALLIANCE:
2189 fc_strlcat(buf, prefix, bufsz);
2190 if (preq->present) {
2191 cat_snprintf(buf, bufsz,
2192 PL_("Requires someone in your current alliance to "
2193 "have culture of at least %d.",
2194 "Requires someone in your current alliance to "
2195 "have culture of at least %d.",
2196 preq->source.value.minculture),
2197 preq->source.value.minculture);
2198 } else {
2199 cat_snprintf(buf, bufsz,
2200 PL_("Prevented if anyone in your current alliance has "
2201 "culture of %d or more.",
2202 "Prevented if anyone in your current alliance has "
2203 "culture of %d or more.",
2204 preq->source.value.minculture),
2205 preq->source.value.minculture);
2206 }
2207 return TRUE;
2208 case REQ_RANGE_WORLD:
2209 fc_strlcat(buf, prefix, bufsz);
2210 if (preq->present) {
2211 cat_snprintf(buf, bufsz,
2212 PL_("Requires that some player has culture of at "
2213 "least %d.",
2214 "Requires that some player has culture of at "
2215 "least %d.",
2216 preq->source.value.minculture),
2217 preq->source.value.minculture);
2218 } else {
2219 cat_snprintf(buf, bufsz,
2220 PL_("Requires that no player has culture of %d "
2221 "or more.",
2222 "Requires that no player has culture of %d "
2223 "or more.",
2224 preq->source.value.minculture),
2225 preq->source.value.minculture);
2226 }
2227 return TRUE;
2228 case REQ_RANGE_LOCAL:
2229 case REQ_RANGE_TILE:
2230 case REQ_RANGE_CADJACENT:
2231 case REQ_RANGE_ADJACENT:
2232 case REQ_RANGE_CONTINENT:
2233 case REQ_RANGE_COUNT:
2234 break;
2235 }
2236 break;
2237
2238 case VUT_MINFOREIGNPCT:
2239 switch (preq->range) {
2240 case REQ_RANGE_CITY:
2241 fc_strlcat(buf, prefix, bufsz);
2242 if (preq->present) {
2243 cat_snprintf(buf, bufsz,
2244 _("At least %d%% of the citizens of the city "
2245 "must be foreign."),
2246 preq->source.value.minforeignpct);
2247 } else {
2248 cat_snprintf(buf, bufsz,
2249 _("Less than %d%% of the citizens of the city "
2250 "must be foreign."),
2251 preq->source.value.minforeignpct);
2252 }
2253 return TRUE;
2254 case REQ_RANGE_TRADE_ROUTE:
2255 fc_strlcat(buf, prefix, bufsz);
2256 if (preq->present) {
2257 cat_snprintf(buf, bufsz,
2258 _("At least %d%% of the citizens of the city "
2259 "or some trade partner must be foreign."),
2260 preq->source.value.minforeignpct);
2261 } else {
2262 cat_snprintf(buf, bufsz,
2263 _("Less than %d%% of the citizens of the city "
2264 "and each trade partner must be foreign."),
2265 preq->source.value.minforeignpct);
2266 }
2267 return TRUE;
2268 case REQ_RANGE_PLAYER:
2269 case REQ_RANGE_TEAM:
2270 case REQ_RANGE_ALLIANCE:
2271 case REQ_RANGE_WORLD:
2272 case REQ_RANGE_LOCAL:
2273 case REQ_RANGE_TILE:
2274 case REQ_RANGE_CADJACENT:
2275 case REQ_RANGE_ADJACENT:
2276 case REQ_RANGE_CONTINENT:
2277 case REQ_RANGE_COUNT:
2278 break;
2279 }
2280 break;
2281
2282 case VUT_MAXTILEUNITS:
2283 switch (preq->range) {
2284 case REQ_RANGE_TILE:
2285 fc_strlcat(buf, prefix, bufsz);
2286 if (preq->present) {
2287 cat_snprintf(buf, bufsz,
2288 PL_("At most %d unit may be present on the tile.",
2289 "At most %d units may be present on the tile.",
2290 preq->source.value.max_tile_units),
2291 preq->source.value.max_tile_units);
2292 } else {
2293 cat_snprintf(buf, bufsz,
2294 PL_("There must be more than %d unit present on "
2295 "the tile.",
2296 "There must be more than %d units present on "
2297 "the tile.",
2298 preq->source.value.max_tile_units),
2299 preq->source.value.max_tile_units);
2300 }
2301 return TRUE;
2302 case REQ_RANGE_CADJACENT:
2303 fc_strlcat(buf, prefix, bufsz);
2304 if (preq->present) {
2305 cat_snprintf(buf, bufsz,
2306 PL_("The tile or at least one cardinally adjacent tile "
2307 "must have %d unit or fewer.",
2308 "The tile or at least one cardinally adjacent tile "
2309 "must have %d units or fewer.",
2310 preq->source.value.max_tile_units),
2311 preq->source.value.max_tile_units);
2312 } else {
2313 cat_snprintf(buf, bufsz,
2314 PL_("The tile and all cardinally adjacent tiles must "
2315 "have more than %d unit each.",
2316 "The tile and all cardinally adjacent tiles must "
2317 "have more than %d units each.",
2318 preq->source.value.max_tile_units),
2319 preq->source.value.max_tile_units);
2320 }
2321 return TRUE;
2322 case REQ_RANGE_ADJACENT:
2323 fc_strlcat(buf, prefix, bufsz);
2324 if (preq->present) {
2325 cat_snprintf(buf, bufsz,
2326 PL_("The tile or at least one adjacent tile must have "
2327 "%d unit or fewer.",
2328 "The tile or at least one adjacent tile must have "
2329 "%d units or fewer.",
2330 preq->source.value.max_tile_units),
2331 preq->source.value.max_tile_units);
2332 } else {
2333 cat_snprintf(buf, bufsz,
2334 PL_("The tile and all adjacent tiles must have more "
2335 "than %d unit each.",
2336 "The tile and all adjacent tiles must have more "
2337 "than %d units each.",
2338 preq->source.value.max_tile_units),
2339 preq->source.value.max_tile_units);
2340 }
2341 return TRUE;
2342 case REQ_RANGE_CITY:
2343 case REQ_RANGE_TRADE_ROUTE:
2344 case REQ_RANGE_CONTINENT:
2345 case REQ_RANGE_PLAYER:
2346 case REQ_RANGE_TEAM:
2347 case REQ_RANGE_ALLIANCE:
2348 case REQ_RANGE_WORLD:
2349 case REQ_RANGE_LOCAL:
2350 case REQ_RANGE_COUNT:
2351 /* Not supported. */
2352 break;
2353 }
2354 break;
2355
2356 case VUT_AI_LEVEL:
2357 if (preq->range != REQ_RANGE_PLAYER) {
2358 break;
2359 }
2360 fc_strlcat(buf, prefix, bufsz);
2361 if (preq->present) {
2362 cat_snprintf(buf, bufsz,
2363 /* TRANS: AI level (e.g., "Handicapped") */
2364 _("Applies to %s AI players."),
2365 ai_level_translated_name(preq->source.value.ai_level));
2366 } else {
2367 cat_snprintf(buf, bufsz,
2368 /* TRANS: AI level (e.g., "Cheating") */
2369 _("Does not apply to %s AI players."),
2370 ai_level_translated_name(preq->source.value.ai_level));
2371 }
2372 return TRUE;
2373
2374 case VUT_TERRAINCLASS:
2375 switch (preq->range) {
2376 case REQ_RANGE_TILE:
2377 fc_strlcat(buf, prefix, bufsz);
2378 if (preq->present) {
2379 cat_snprintf(buf, bufsz,
2380 /* TRANS: %s is a terrain class */
2381 Q_("?terrainclass:Requires %s terrain on the tile."),
2382 terrain_class_name_translation
2383 (preq->source.value.terrainclass));
2384 } else {
2385 cat_snprintf(buf, bufsz,
2386 /* TRANS: %s is a terrain class */
2387 Q_("?terrainclass:Prevented by %s terrain on the tile."),
2388 terrain_class_name_translation
2389 (preq->source.value.terrainclass));
2390 }
2391 return TRUE;
2392 case REQ_RANGE_CADJACENT:
2393 fc_strlcat(buf, prefix, bufsz);
2394 if (preq->present) {
2395 cat_snprintf(buf, bufsz,
2396 /* TRANS: %s is a terrain class */
2397 Q_("?terrainclass:Requires %s terrain on the tile or a "
2398 "cardinally adjacent tile."),
2399 terrain_class_name_translation
2400 (preq->source.value.terrainclass));
2401 } else {
2402 cat_snprintf(buf, bufsz,
2403 /* TRANS: %s is a terrain class */
2404 Q_("?terrainclass:Prevented by %s terrain on the tile or "
2405 "any cardinally adjacent tile."),
2406 terrain_class_name_translation
2407 (preq->source.value.terrainclass));
2408 }
2409 return TRUE;
2410 case REQ_RANGE_ADJACENT:
2411 fc_strlcat(buf, prefix, bufsz);
2412 if (preq->present) {
2413 cat_snprintf(buf, bufsz,
2414 /* TRANS: %s is a terrain class */
2415 Q_("?terrainclass:Requires %s terrain on the tile or an "
2416 "adjacent tile."),
2417 terrain_class_name_translation
2418 (preq->source.value.terrainclass));
2419 } else {
2420 cat_snprintf(buf, bufsz,
2421 /* TRANS: %s is a terrain class */
2422 Q_("?terrainclass:Prevented by %s terrain on the tile or "
2423 "any adjacent tile."),
2424 terrain_class_name_translation
2425 (preq->source.value.terrainclass));
2426 }
2427 return TRUE;
2428 case REQ_RANGE_CITY:
2429 fc_strlcat(buf, prefix, bufsz);
2430 if (preq->present) {
2431 cat_snprintf(buf, bufsz,
2432 /* TRANS: %s is a terrain class */
2433 Q_("?terrainclass:Requires %s terrain on a tile within "
2434 "the city radius."),
2435 terrain_class_name_translation
2436 (preq->source.value.terrainclass));
2437 } else {
2438 cat_snprintf(buf, bufsz,
2439 /* TRANS: %s is a terrain class */
2440 Q_("?terrainclass:Prevented by %s terrain on any tile "
2441 "within the city radius."),
2442 terrain_class_name_translation
2443 (preq->source.value.terrainclass));
2444 }
2445 return TRUE;
2446 case REQ_RANGE_TRADE_ROUTE:
2447 fc_strlcat(buf, prefix, bufsz);
2448 if (preq->present) {
2449 cat_snprintf(buf, bufsz,
2450 /* TRANS: %s is a terrain class */
2451 Q_("?terrainclass:Requires %s terrain on a tile within "
2452 "the city radius or the city radius of a trade "
2453 "partner."),
2454 terrain_class_name_translation
2455 (preq->source.value.terrainclass));
2456 } else {
2457 cat_snprintf(buf, bufsz,
2458 /* TRANS: %s is a terrain class */
2459 Q_("?terrainclass:Prevented by %s terrain on any tile "
2460 "within the city radius or the city radius of a trade "
2461 "partner."),
2462 terrain_class_name_translation
2463 (preq->source.value.terrainclass));
2464 }
2465 return TRUE;
2466 case REQ_RANGE_CONTINENT:
2467 case REQ_RANGE_PLAYER:
2468 case REQ_RANGE_TEAM:
2469 case REQ_RANGE_ALLIANCE:
2470 case REQ_RANGE_WORLD:
2471 case REQ_RANGE_LOCAL:
2472 case REQ_RANGE_COUNT:
2473 /* Not supported. */
2474 break;
2475 }
2476 break;
2477
2478 case VUT_TERRFLAG:
2479 switch (preq->range) {
2480 case REQ_RANGE_TILE:
2481 fc_strlcat(buf, prefix, bufsz);
2482 if (preq->present) {
2483 cat_snprintf(buf, bufsz,
2484 /* TRANS: %s is a (translatable) terrain flag. */
2485 _("Requires terrain with the \"%s\" flag on the tile."),
2486 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2487 } else {
2488 cat_snprintf(buf, bufsz,
2489 /* TRANS: %s is a (translatable) terrain flag. */
2490 _("Prevented by terrain with the \"%s\" flag on the "
2491 "tile."),
2492 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2493 }
2494 return TRUE;
2495 case REQ_RANGE_CADJACENT:
2496 fc_strlcat(buf, prefix, bufsz);
2497 if (preq->present) {
2498 cat_snprintf(buf, bufsz,
2499 /* TRANS: %s is a (translatable) terrain flag. */
2500 _("Requires terrain with the \"%s\" flag on the "
2501 "tile or a cardinally adjacent tile."),
2502 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2503 } else {
2504 cat_snprintf(buf, bufsz,
2505 /* TRANS: %s is a (translatable) terrain flag. */
2506 _("Prevented by terrain with the \"%s\" flag on "
2507 "the tile or any cardinally adjacent tile."),
2508 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2509 }
2510 return TRUE;
2511 case REQ_RANGE_ADJACENT:
2512 fc_strlcat(buf, prefix, bufsz);
2513 if (preq->present) {
2514 cat_snprintf(buf, bufsz,
2515 /* TRANS: %s is a (translatable) terrain flag. */
2516 _("Requires terrain with the \"%s\" flag on the "
2517 "tile or an adjacent tile."),
2518 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2519 } else {
2520 cat_snprintf(buf, bufsz,
2521 /* TRANS: %s is a (translatable) terrain flag. */
2522 _("Prevented by terrain with the \"%s\" flag on "
2523 "the tile or any adjacent tile."),
2524 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2525 }
2526 return TRUE;
2527 case REQ_RANGE_CITY:
2528 fc_strlcat(buf, prefix, bufsz);
2529 if (preq->present) {
2530 cat_snprintf(buf, bufsz,
2531 /* TRANS: %s is a (translatable) terrain flag. */
2532 _("Requires terrain with the \"%s\" flag on a tile "
2533 "within the city radius."),
2534 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2535 } else {
2536 cat_snprintf(buf, bufsz,
2537 /* TRANS: %s is a (translatable) terrain flag. */
2538 _("Prevented by terrain with the \"%s\" flag on any tile "
2539 "within the city radius."),
2540 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2541 }
2542 return TRUE;
2543 case REQ_RANGE_TRADE_ROUTE:
2544 fc_strlcat(buf, prefix, bufsz);
2545 if (preq->present) {
2546 cat_snprintf(buf, bufsz,
2547 /* TRANS: %s is a (translatable) terrain flag. */
2548 _("Requires terrain with the \"%s\" flag on a tile "
2549 "within the city radius or the city radius of "
2550 "a trade partner."),
2551 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2552 } else {
2553 cat_snprintf(buf, bufsz,
2554 /* TRANS: %s is a (translatable) terrain flag. */
2555 _("Prevented by terrain with the \"%s\" flag on any tile "
2556 "within the city radius or the city radius of "
2557 "a trade partner."),
2558 terrain_flag_id_translated_name(preq->source.value.terrainflag));
2559 }
2560 return TRUE;
2561 case REQ_RANGE_CONTINENT:
2562 case REQ_RANGE_PLAYER:
2563 case REQ_RANGE_TEAM:
2564 case REQ_RANGE_ALLIANCE:
2565 case REQ_RANGE_WORLD:
2566 case REQ_RANGE_LOCAL:
2567 case REQ_RANGE_COUNT:
2568 /* Not supported. */
2569 break;
2570 }
2571 break;
2572
2573 case VUT_ROADFLAG:
2574 switch (preq->range) {
2575 case REQ_RANGE_LOCAL:
2576 fc_strlcat(buf, prefix, bufsz);
2577 if (preq->present) {
2578 cat_snprintf(buf, bufsz,
2579 /* TRANS: %s is a (translatable) road flag. */
2580 _("Only applies to roads with the \"%s\" flag."),
2581 road_flag_id_translated_name
2582 (preq->source.value.roadflag));
2583 } else {
2584 cat_snprintf(buf, bufsz,
2585 /* TRANS: %s is a (translatable) road flag. */
2586 _("Does not apply to roads with the \"%s\" flag."),
2587 road_flag_id_translated_name
2588 (preq->source.value.roadflag));
2589 }
2590 return TRUE;
2591 case REQ_RANGE_TILE:
2592 fc_strlcat(buf, prefix, bufsz);
2593 if (preq->present) {
2594 cat_snprintf(buf, bufsz,
2595 /* TRANS: %s is a (translatable) road flag. */
2596 _("Requires a road with the \"%s\" flag on the tile."),
2597 road_flag_id_translated_name(preq->source.value.roadflag));
2598 } else {
2599 cat_snprintf(buf, bufsz,
2600 /* TRANS: %s is a (translatable) road flag. */
2601 _("Prevented by a road with the \"%s\" flag on the "
2602 "tile."),
2603 road_flag_id_translated_name(preq->source.value.roadflag));
2604 }
2605 return TRUE;
2606 case REQ_RANGE_CADJACENT:
2607 fc_strlcat(buf, prefix, bufsz);
2608 if (preq->present) {
2609 cat_snprintf(buf, bufsz,
2610 /* TRANS: %s is a (translatable) road flag. */
2611 _("Requires a road with the \"%s\" flag on the "
2612 "tile or a cardinally adjacent tile."),
2613 road_flag_id_translated_name(preq->source.value.roadflag));
2614 } else {
2615 cat_snprintf(buf, bufsz,
2616 /* TRANS: %s is a (translatable) road flag. */
2617 _("Prevented by a road with the \"%s\" flag on "
2618 "the tile or any cardinally adjacent tile."),
2619 road_flag_id_translated_name(preq->source.value.roadflag));
2620 }
2621 return TRUE;
2622 case REQ_RANGE_ADJACENT:
2623 fc_strlcat(buf, prefix, bufsz);
2624 if (preq->present) {
2625 cat_snprintf(buf, bufsz,
2626 /* TRANS: %s is a (translatable) road flag. */
2627 _("Requires a road with the \"%s\" flag on the "
2628 "tile or an adjacent tile."),
2629 road_flag_id_translated_name(preq->source.value.roadflag));
2630 } else {
2631 cat_snprintf(buf, bufsz,
2632 /* TRANS: %s is a (translatable) road flag. */
2633 _("Prevented by a road with the \"%s\" flag on "
2634 "the tile or any adjacent tile."),
2635 road_flag_id_translated_name(preq->source.value.roadflag));
2636 }
2637 return TRUE;
2638 case REQ_RANGE_CITY:
2639 fc_strlcat(buf, prefix, bufsz);
2640 if (preq->present) {
2641 cat_snprintf(buf, bufsz,
2642 /* TRANS: %s is a (translatable) road flag. */
2643 _("Requires a road with the \"%s\" flag on a tile "
2644 "within the city radius."),
2645 road_flag_id_translated_name(preq->source.value.roadflag));
2646 } else {
2647 cat_snprintf(buf, bufsz,
2648 /* TRANS: %s is a (translatable) road flag. */
2649 _("Prevented by a road with the \"%s\" flag on any tile "
2650 "within the city radius."),
2651 road_flag_id_translated_name(preq->source.value.roadflag));
2652 }
2653 return TRUE;
2654 case REQ_RANGE_TRADE_ROUTE:
2655 fc_strlcat(buf, prefix, bufsz);
2656 if (preq->present) {
2657 cat_snprintf(buf, bufsz,
2658 /* TRANS: %s is a (translatable) road flag. */
2659 _("Requires a road with the \"%s\" flag on a tile "
2660 "within the city radius or the city radius of a "
2661 "trade partner."),
2662 road_flag_id_translated_name(preq->source.value.roadflag));
2663 } else {
2664 cat_snprintf(buf, bufsz,
2665 /* TRANS: %s is a (translatable) road flag. */
2666 _("Prevented by a road with the \"%s\" flag on any tile "
2667 "within the city radius or the city radius of a "
2668 "trade partner."),
2669 road_flag_id_translated_name(preq->source.value.roadflag));
2670 }
2671 return TRUE;
2672 case REQ_RANGE_CONTINENT:
2673 case REQ_RANGE_PLAYER:
2674 case REQ_RANGE_TEAM:
2675 case REQ_RANGE_ALLIANCE:
2676 case REQ_RANGE_WORLD:
2677 case REQ_RANGE_COUNT:
2678 /* Not supported. */
2679 break;
2680 }
2681 break;
2682
2683 case VUT_EXTRAFLAG:
2684 switch (preq->range) {
2685 case REQ_RANGE_LOCAL:
2686 fc_strlcat(buf, prefix, bufsz);
2687 if (preq->present) {
2688 cat_snprintf(buf, bufsz,
2689 /* TRANS: %s is a (translatable) extra flag. */
2690 _("Only applies to extras with the \"%s\" flag."),
2691 extra_flag_id_translated_name
2692 (preq->source.value.extraflag));
2693 } else {
2694 cat_snprintf(buf, bufsz,
2695 /* TRANS: %s is a (translatable) extra flag. */
2696 _("Does not apply to extras with the \"%s\" flag."),
2697 extra_flag_id_translated_name
2698 (preq->source.value.extraflag));
2699 }
2700 return TRUE;
2701 case REQ_RANGE_TILE:
2702 fc_strlcat(buf, prefix, bufsz);
2703 if (preq->present) {
2704 cat_snprintf(buf, bufsz,
2705 /* TRANS: %s is a (translatable) extra flag. */
2706 _("Requires an extra with the \"%s\" flag on the tile."),
2707 extra_flag_id_translated_name(preq->source.value.extraflag));
2708 } else {
2709 cat_snprintf(buf, bufsz,
2710 /* TRANS: %s is a (translatable) extra flag. */
2711 _("Prevented by an extra with the \"%s\" flag on the "
2712 "tile."),
2713 extra_flag_id_translated_name(preq->source.value.extraflag));
2714 }
2715 return TRUE;
2716 case REQ_RANGE_CADJACENT:
2717 fc_strlcat(buf, prefix, bufsz);
2718 if (preq->present) {
2719 cat_snprintf(buf, bufsz,
2720 /* TRANS: %s is a (translatable) extra flag. */
2721 _("Requires an extra with the \"%s\" flag on the "
2722 "tile or a cardinally adjacent tile."),
2723 extra_flag_id_translated_name(preq->source.value.extraflag));
2724 } else {
2725 cat_snprintf(buf, bufsz,
2726 /* TRANS: %s is a (translatable) extra flag. */
2727 _("Prevented by an extra with the \"%s\" flag on "
2728 "the tile or any cardinally adjacent tile."),
2729 extra_flag_id_translated_name(preq->source.value.extraflag));
2730 }
2731 return TRUE;
2732 case REQ_RANGE_ADJACENT:
2733 fc_strlcat(buf, prefix, bufsz);
2734 if (preq->present) {
2735 cat_snprintf(buf, bufsz,
2736 /* TRANS: %s is a (translatable) extra flag. */
2737 _("Requires an extra with the \"%s\" flag on the "
2738 "tile or an adjacent tile."),
2739 extra_flag_id_translated_name(preq->source.value.extraflag));
2740 } else {
2741 cat_snprintf(buf, bufsz,
2742 /* TRANS: %s is a (translatable) extra flag. */
2743 _("Prevented by an extra with the \"%s\" flag on "
2744 "the tile or any adjacent tile."),
2745 extra_flag_id_translated_name(preq->source.value.extraflag));
2746 }
2747 return TRUE;
2748 case REQ_RANGE_CITY:
2749 fc_strlcat(buf, prefix, bufsz);
2750 if (preq->present) {
2751 cat_snprintf(buf, bufsz,
2752 /* TRANS: %s is a (translatable) extra flag. */
2753 _("Requires an extra with the \"%s\" flag on a tile "
2754 "within the city radius."),
2755 extra_flag_id_translated_name(preq->source.value.extraflag));
2756 } else {
2757 cat_snprintf(buf, bufsz,
2758 /* TRANS: %s is a (translatable) extra flag. */
2759 _("Prevented by an extra with the \"%s\" flag on any tile "
2760 "within the city radius."),
2761 extra_flag_id_translated_name(preq->source.value.extraflag));
2762 }
2763 return TRUE;
2764 case REQ_RANGE_TRADE_ROUTE:
2765 fc_strlcat(buf, prefix, bufsz);
2766 if (preq->present) {
2767 cat_snprintf(buf, bufsz,
2768 /* TRANS: %s is a (translatable) extra flag. */
2769 _("Requires an extra with the \"%s\" flag on a tile "
2770 "within the city radius or the city radius of a "
2771 "trade partner."),
2772 extra_flag_id_translated_name(preq->source.value.extraflag));
2773 } else {
2774 cat_snprintf(buf, bufsz,
2775 /* TRANS: %s is a (translatable) extra flag. */
2776 _("Prevented by an extra with the \"%s\" flag on any tile "
2777 "within the city radius or the city radius of a "
2778 "trade partner."),
2779 extra_flag_id_translated_name(preq->source.value.extraflag));
2780 }
2781 return TRUE;
2782 case REQ_RANGE_CONTINENT:
2783 case REQ_RANGE_PLAYER:
2784 case REQ_RANGE_TEAM:
2785 case REQ_RANGE_ALLIANCE:
2786 case REQ_RANGE_WORLD:
2787 case REQ_RANGE_COUNT:
2788 /* Not supported. */
2789 break;
2790 }
2791 break;
2792
2793 case VUT_MINYEAR:
2794 if (preq->range != REQ_RANGE_WORLD) {
2795 break;
2796 }
2797 fc_strlcat(buf, prefix, bufsz);
2798 if (preq->present) {
2799 cat_snprintf(buf, bufsz,
2800 _("Requires the game to have reached the year %s."),
2801 textyear(preq->source.value.minyear));
2802 } else {
2803 cat_snprintf(buf, bufsz,
2804 _("Requires that the game has not yet reached the "
2805 "year %s."),
2806 textyear(preq->source.value.minyear));
2807 }
2808 return TRUE;
2809
2810 case VUT_MINCALFRAG:
2811 if (preq->range != REQ_RANGE_WORLD) {
2812 break;
2813 }
2814 fc_strlcat(buf, prefix, bufsz);
2815 if (preq->present) {
2816 cat_snprintf(buf, bufsz,
2817 /* TRANS: %s is a representation of a calendar fragment,
2818 * from the ruleset. May be a bare number. */
2819 _("Requires the game to have reached %s."),
2820 textcalfrag(preq->source.value.mincalfrag));
2821 } else {
2822 cat_snprintf(buf, bufsz,
2823 /* TRANS: %s is a representation of a calendar fragment,
2824 * from the ruleset. May be a bare number. */
2825 _("Requires that the game has not yet reached %s."),
2826 textcalfrag(preq->source.value.mincalfrag));
2827 }
2828 return TRUE;
2829
2830 case VUT_TOPO:
2831 if (preq->range != REQ_RANGE_WORLD) {
2832 break;
2833 }
2834 fc_strlcat(buf, prefix, bufsz);
2835 if (preq->present) {
2836 cat_snprintf(buf, bufsz,
2837 /* TRANS: topology flag name ("Hex", "ISO") */
2838 _("Requires %s map."),
2839 _(topo_flag_name(preq->source.value.topo_property)));
2840 } else {
2841 cat_snprintf(buf, bufsz,
2842 /* TRANS: topology flag name ("Hex", "ISO") */
2843 _("Prevented on %s map."),
2844 _(topo_flag_name(preq->source.value.topo_property)));
2845 }
2846 return TRUE;
2847
2848 case VUT_WRAP:
2849 if (preq->range != REQ_RANGE_WORLD) {
2850 break;
2851 }
2852 fc_strlcat(buf, prefix, bufsz);
2853 if (preq->present) {
2854 cat_snprintf(buf, bufsz,
2855 /* TRANS: wrap flag name ("WrapX", "WrapY") */
2856 _("Requires %s map."),
2857 _(wrap_flag_name(preq->source.value.wrap_property)));
2858 } else {
2859 cat_snprintf(buf, bufsz,
2860 /* TRANS: wrap flag name ("WrapX", "WrapY") */
2861 _("Prevented on %s map."),
2862 _(wrap_flag_name(preq->source.value.wrap_property)));
2863 }
2864 return TRUE;
2865
2866 case VUT_SERVERSETTING:
2867 if (preq->range != REQ_RANGE_WORLD) {
2868 break;
2869 }
2870 fc_strlcat(buf, prefix, bufsz);
2871 cat_snprintf(buf, bufsz,
2872 /* TRANS: %s is a server setting, its value and if it is
2873 * required to be present or absent. The string's format
2874 * is specified in ssetv_human_readable().
2875 * Example: "killstack is enabled". */
2876 _("Requires that the server setting %s."),
2877 ssetv_human_readable(preq->source.value.ssetval,
2878 preq->present));
2879 return TRUE;
2880
2881 case VUT_AGE:
2882 fc_strlcat(buf, prefix, bufsz);
2883 if (preq->present) {
2884 cat_snprintf(buf, bufsz,
2885 _("Requires age of %d turns."),
2886 preq->source.value.age);
2887 } else {
2888 cat_snprintf(buf, bufsz,
2889 _("Prevented if age is over %d turns."),
2890 preq->source.value.age);
2891 }
2892 return TRUE;
2893
2894 case VUT_FORM_AGE:
2895 fc_strlcat(buf, prefix, bufsz);
2896 if (preq->present) {
2897 cat_snprintf(buf, bufsz,
2898 _("Requires form age of %d turns."),
2899 preq->source.value.form_age);
2900 } else {
2901 cat_snprintf(buf, bufsz,
2902 _("Prevented if form age is over %d turns."),
2903 preq->source.value.form_age);
2904 }
2905 return TRUE;
2906
2907 case VUT_MINTECHS:
2908 switch (preq->range) {
2909 case REQ_RANGE_WORLD:
2910 fc_strlcat(buf, prefix, bufsz);
2911 if (preq->present) {
2912 cat_snprintf(buf, bufsz,
2913 _("Requires %d techs to be known in the world."),
2914 preq->source.value.min_techs);
2915 } else {
2916 cat_snprintf(buf, bufsz,
2917 _("Prevented when %d techs are known in the world."),
2918 preq->source.value.min_techs);
2919 }
2920 return TRUE;
2921 case REQ_RANGE_PLAYER:
2922 fc_strlcat(buf, prefix, bufsz);
2923 if (preq->present) {
2924 cat_snprintf(buf, bufsz,
2925 _("Requires player to know %d techs."),
2926 preq->source.value.min_techs);
2927 } else {
2928 cat_snprintf(buf, bufsz,
2929 _("Prevented when player knows %d techs."),
2930 preq->source.value.min_techs);
2931 }
2932 return TRUE;
2933 case REQ_RANGE_LOCAL:
2934 case REQ_RANGE_TILE:
2935 case REQ_RANGE_CADJACENT:
2936 case REQ_RANGE_ADJACENT:
2937 case REQ_RANGE_CITY:
2938 case REQ_RANGE_TRADE_ROUTE:
2939 case REQ_RANGE_CONTINENT:
2940 case REQ_RANGE_TEAM:
2941 case REQ_RANGE_ALLIANCE:
2942 case REQ_RANGE_COUNT:
2943 /* Not supported. */
2944 break;
2945 }
2946 break;
2947
2948 case VUT_MINCITIES:
2949 switch (preq->range) {
2950 case REQ_RANGE_PLAYER:
2951 fc_strlcat(buf, prefix, bufsz);
2952 if (preq->present) {
2953 cat_snprintf(buf, bufsz,
2954 _("Requires player to have at least %d cities."),
2955 preq->source.value.min_cities);
2956 } else {
2957 cat_snprintf(buf, bufsz,
2958 _("Prevented when player has at least %d cities."),
2959 preq->source.value.min_cities);
2960 }
2961 return TRUE;
2962 case REQ_RANGE_WORLD:
2963 case REQ_RANGE_LOCAL:
2964 case REQ_RANGE_TILE:
2965 case REQ_RANGE_CADJACENT:
2966 case REQ_RANGE_ADJACENT:
2967 case REQ_RANGE_CITY:
2968 case REQ_RANGE_TRADE_ROUTE:
2969 case REQ_RANGE_CONTINENT:
2970 case REQ_RANGE_TEAM:
2971 case REQ_RANGE_ALLIANCE:
2972 case REQ_RANGE_COUNT:
2973 /* Not supported. */
2974 break;
2975 }
2976 break;
2977
2978 case VUT_TERRAINALTER:
2979 switch (preq->range) {
2980 case REQ_RANGE_TILE:
2981 fc_strlcat(buf, prefix, bufsz);
2982 if (preq->present) {
2983 cat_snprintf(buf, bufsz,
2984 _("Requires terrain on which alteration %s is "
2985 "possible."),
2986 Q_(terrain_alteration_name(preq->source.value.terrainalter)));
2987 } else {
2988 cat_snprintf(buf, bufsz,
2989 _("Prevented by terrain on which alteration %s "
2990 "can be made."),
2991 Q_(terrain_alteration_name(preq->source.value.terrainalter)));
2992 }
2993 return TRUE;
2994 case REQ_RANGE_CADJACENT:
2995 case REQ_RANGE_ADJACENT:
2996 case REQ_RANGE_CITY:
2997 case REQ_RANGE_TRADE_ROUTE:
2998 case REQ_RANGE_CONTINENT:
2999 case REQ_RANGE_PLAYER:
3000 case REQ_RANGE_TEAM:
3001 case REQ_RANGE_ALLIANCE:
3002 case REQ_RANGE_WORLD:
3003 case REQ_RANGE_LOCAL:
3004 case REQ_RANGE_COUNT:
3005 /* Not supported. */
3006 break;
3007 }
3008 break;
3009
3010 case VUT_CITYTILE:
3011 if (preq->source.value.citytile == CITYT_LAST) {
3012 break;
3013 } else {
3014 static char *tile_property = NULL;
3015
3016 switch (preq->source.value.citytile) {
3017 case CITYT_CENTER:
3018 tile_property = _("city centers");
3019 break;
3020 case CITYT_CLAIMED:
3021 tile_property = _("claimed tiles");
3022 break;
3023 case CITYT_EXTRAS_OWNED:
3024 tile_property = _("owned extras");
3025 break;
3026 case CITYT_WORKED:
3027 tile_property = _("worked tiles");
3028 break;
3029 case CITYT_SAME_CONTINENT:
3030 /* TRANS: a specific city for each use case */
3031 tile_property = _("tiles on the same continent as the city");
3032 break;
3033 case CITYT_BORDERING_TCLASS_REGION:
3034 {
3035 bool oceanic_cities = FALSE; /* FIXME: maybe cache globally? */
3036
3037 terrain_type_iterate(tt) {
3038 if (terrain_type_terrain_class(tt) == TC_OCEAN
3039 && !terrain_has_flag(tt, TER_NO_CITIES)) {
3040 oceanic_cities = TRUE;
3041 /* TRANS: a specific city for each use case */
3042 tile_property = _("tiles of a mass of a different "
3043 "terrain class next to the city");
3044 break;
3045 }
3046 } terrain_type_iterate_end;
3047 if (oceanic_cities) {
3048 break;
3049 }
3050 /* TRANS: a specific city for each use case */
3051 tile_property = _("tiles of a body of water next to the city");
3052 }
3053 break;
3054 case CITYT_LAST:
3055 fc_assert(preq->source.value.citytile != CITYT_LAST);
3056 break;
3057 }
3058
3059 switch (preq->range) {
3060 case REQ_RANGE_TILE:
3061 fc_strlcat(buf, prefix, bufsz);
3062 if (preq->present) {
3063 cat_snprintf(buf, bufsz,
3064 /* TRANS: tile property ("city centers", etc) */
3065 Q_("?tileprop:Applies only to %s."), tile_property);
3066 } else {
3067 cat_snprintf(buf, bufsz,
3068 /* TRANS: tile property ("city centers", etc) */
3069 Q_("?tileprop:Does not apply to %s."), tile_property);
3070 }
3071 return TRUE;
3072 case REQ_RANGE_CADJACENT:
3073 fc_strlcat(buf, prefix, bufsz);
3074 if (preq->present) {
3075 /* TRANS: tile property ("city centers", etc) */
3076 cat_snprintf(buf, bufsz, Q_("?tileprop:Applies only to %s and "
3077 "cardinally adjacent tiles."),
3078 tile_property);
3079 } else {
3080 /* TRANS: tile property ("city centers", etc) */
3081 cat_snprintf(buf, bufsz, Q_("?tileprop:Does not apply to %s or "
3082 "cardinally adjacent tiles."),
3083 tile_property);
3084 }
3085 return TRUE;
3086 case REQ_RANGE_ADJACENT:
3087 fc_strlcat(buf, prefix, bufsz);
3088 if (preq->present) {
3089 /* TRANS: tile property ("city centers", etc) */
3090 cat_snprintf(buf, bufsz, Q_("?tileprop:Applies only to %s and "
3091 "adjacent tiles."), tile_property);
3092 } else {
3093 /* TRANS: tile property ("city centers", etc) */
3094 cat_snprintf(buf, bufsz, Q_("?tileprop:Does not apply to %s or "
3095 "adjacent tiles."), tile_property);
3096 }
3097 return TRUE;
3098 case REQ_RANGE_CITY:
3099 case REQ_RANGE_TRADE_ROUTE:
3100 case REQ_RANGE_CONTINENT:
3101 case REQ_RANGE_PLAYER:
3102 case REQ_RANGE_TEAM:
3103 case REQ_RANGE_ALLIANCE:
3104 case REQ_RANGE_WORLD:
3105 case REQ_RANGE_LOCAL:
3106 case REQ_RANGE_COUNT:
3107 /* Not supported. */
3108 break;
3109 }
3110
3111 break;
3112 }
3113
3114 case VUT_CITYSTATUS:
3115 if (preq->source.value.citystatus != CITYS_LAST) {
3116 static char *city_property = NULL;
3117
3118 switch (preq->source.value.citystatus) {
3119 case CITYS_OWNED_BY_ORIGINAL:
3120 city_property = _("owned by original");
3121 break;
3122 case CITYS_STARVED:
3123 city_property = _("starved");
3124 break;
3125 case CITYS_DISORDER:
3126 city_property = _("disorder");
3127 break;
3128 case CITYS_CELEBRATION:
3129 city_property = _("celebration");
3130 break;
3131 case CITYS_TRANSFERRED:
3132 city_property = _("transferred");
3133 break;
3134 case CITYS_LAST:
3135 fc_assert(preq->source.value.citystatus != CITYS_LAST);
3136 break;
3137 }
3138
3139 switch (preq->range) {
3140 case REQ_RANGE_CITY:
3141 fc_strlcat(buf, prefix, bufsz);
3142 if (preq->present) {
3143 /* TRANS: city property ("owned by original", etc) */
3144 cat_snprintf(buf, bufsz, Q_("?cityprop:Applies only to %s cities"),
3145 city_property);
3146 } else {
3147 /* TRANS: city property ("owned by original", etc) */
3148 cat_snprintf(buf, bufsz, Q_("?cityprop:Does not apply to %s cities"),
3149 city_property);
3150 }
3151 return TRUE;
3152 case REQ_RANGE_TRADE_ROUTE:
3153 fc_strlcat(buf, prefix, bufsz);
3154 if (preq->present) {
3155 /* TRANS: city property ("owned by original", etc) */
3156 cat_snprintf(buf, bufsz, Q_("?cityprop:Applies only to %s cities or "
3157 "their trade partners."), city_property);
3158 } else {
3159 /* TRANS: city property ("owned by original", etc) */
3160 cat_snprintf(buf, bufsz, Q_("?cityprop:Does not apply to %s cities or "
3161 "their trade partners."), city_property);
3162 }
3163 return TRUE;
3164 case REQ_RANGE_LOCAL:
3165 case REQ_RANGE_TILE:
3166 case REQ_RANGE_ADJACENT:
3167 case REQ_RANGE_CADJACENT:
3168 case REQ_RANGE_CONTINENT:
3169 case REQ_RANGE_PLAYER:
3170 case REQ_RANGE_TEAM:
3171 case REQ_RANGE_ALLIANCE:
3172 case REQ_RANGE_WORLD:
3173 case REQ_RANGE_COUNT:
3174 /* Not supported. */
3175 break;
3176 }
3177 }
3178 break;
3179
3180 case VUT_MINLATITUDE:
3181 switch (preq->range) {
3182 case REQ_RANGE_WORLD:
3183 fc_strlcat(buf, prefix, bufsz);
3184 if (preq->present) {
3185 cat_snprintf(buf, bufsz,
3186 _("Some part of the world must be at latitude %d or "
3187 "further north."),
3188 preq->source.value.latitude);
3189 } else {
3190 cat_snprintf(buf, bufsz,
3191 _("The entire world must be at latitude %d or "
3192 "further south."),
3193 preq->source.value.latitude - 1);
3194 }
3195 return TRUE;
3196 case REQ_RANGE_TILE:
3197 fc_strlcat(buf, prefix, bufsz);
3198 if (preq->present) {
3199 cat_snprintf(buf, bufsz,
3200 _("Tile must be at latitude %d or further north."),
3201 preq->source.value.latitude);
3202 } else {
3203 cat_snprintf(buf, bufsz,
3204 _("Tile must be at latitude %d or further south."),
3205 preq->source.value.latitude - 1);
3206 }
3207 return TRUE;
3208 case REQ_RANGE_CADJACENT:
3209 fc_strlcat(buf, prefix, bufsz);
3210 if (preq->present) {
3211 cat_snprintf(buf, bufsz,
3212 _("A cardinally adjacent tile must be at latitude "
3213 "%d or further north."),
3214 preq->source.value.latitude);
3215 } else {
3216 cat_snprintf(buf, bufsz,
3217 _("All cardinally adjacent tiles must be at latitude "
3218 "%d or further south."),
3219 preq->source.value.latitude - 1);
3220 }
3221 return TRUE;
3222 case REQ_RANGE_ADJACENT:
3223 fc_strlcat(buf, prefix, bufsz);
3224 if (preq->present) {
3225 cat_snprintf(buf, bufsz,
3226 _("An adjacent tile must be at latitude %d or "
3227 "further north."),
3228 preq->source.value.latitude);
3229 } else {
3230 cat_snprintf(buf, bufsz,
3231 _("All adjacent tiles must be at latitude %d or "
3232 "further south."),
3233 preq->source.value.latitude - 1);
3234 }
3235 return TRUE;
3236 case REQ_RANGE_CITY:
3237 case REQ_RANGE_TRADE_ROUTE:
3238 case REQ_RANGE_CONTINENT:
3239 case REQ_RANGE_PLAYER:
3240 case REQ_RANGE_TEAM:
3241 case REQ_RANGE_ALLIANCE:
3242 case REQ_RANGE_LOCAL:
3243 case REQ_RANGE_COUNT:
3244 /* Not supported. */
3245 break;
3246 }
3247 break;
3248
3249 case VUT_MAXLATITUDE:
3250 switch (preq->range) {
3251 case REQ_RANGE_WORLD:
3252 fc_strlcat(buf, prefix, bufsz);
3253 if (preq->present) {
3254 cat_snprintf(buf, bufsz,
3255 _("Some part of the world must be at latitude %d or "
3256 "further south."),
3257 preq->source.value.latitude);
3258 } else {
3259 cat_snprintf(buf, bufsz,
3260 _("The entire world must be at latitude %d or "
3261 "further north."),
3262 preq->source.value.latitude + 1);
3263 }
3264 return TRUE;
3265 case REQ_RANGE_TILE:
3266 fc_strlcat(buf, prefix, bufsz);
3267 if (preq->present) {
3268 cat_snprintf(buf, bufsz,
3269 _("Tile must be at latitude %d or further south."),
3270 preq->source.value.latitude);
3271 } else {
3272 cat_snprintf(buf, bufsz,
3273 _("Tile must be at latitude %d or further north."),
3274 preq->source.value.latitude + 1);
3275 }
3276 return TRUE;
3277 case REQ_RANGE_CADJACENT:
3278 fc_strlcat(buf, prefix, bufsz);
3279 if (preq->present) {
3280 cat_snprintf(buf, bufsz,
3281 _("A cardinally adjacent tile must be at latitude "
3282 "%d or further south."),
3283 preq->source.value.latitude);
3284 } else {
3285 cat_snprintf(buf, bufsz,
3286 _("All cardinally adjacent tiles must be at latitude "
3287 "%d or further north."),
3288 preq->source.value.latitude + 1);
3289 }
3290 return TRUE;
3291 case REQ_RANGE_ADJACENT:
3292 fc_strlcat(buf, prefix, bufsz);
3293 if (preq->present) {
3294 cat_snprintf(buf, bufsz,
3295 _("An adjacent tile must be at latitude %d or "
3296 "further south."),
3297 preq->source.value.latitude);
3298 } else {
3299 cat_snprintf(buf, bufsz,
3300 _("All adjacent tiles must be at latitude %d or "
3301 "further north."),
3302 preq->source.value.latitude + 1);
3303 }
3304 return TRUE;
3305 case REQ_RANGE_CITY:
3306 case REQ_RANGE_TRADE_ROUTE:
3307 case REQ_RANGE_CONTINENT:
3308 case REQ_RANGE_PLAYER:
3309 case REQ_RANGE_TEAM:
3310 case REQ_RANGE_ALLIANCE:
3311 case REQ_RANGE_LOCAL:
3312 case REQ_RANGE_COUNT:
3313 /* Not supported. */
3314 break;
3315 }
3316 break;
3317
3318 case VUT_MAX_DISTANCE_SQ:
3319 switch (preq->range) {
3320 case REQ_RANGE_TILE:
3321 fc_strlcat(buf, prefix, bufsz);
3322 /* Test some special cases */
3323 switch (preq->source.value.distance_sq)
3324 {
3325 case 0:
3326 if (preq->present) {
3327 fc_strlcat(buf, _("Must be the same tile."), bufsz);
3328 } else {
3329 fc_strlcat(buf, _("Must not be the same tile."), bufsz);
3330 }
3331 break;
3332 case 1:
3333 if (preq->present) {
3334 fc_strlcat(buf, _("Must be cardinally adjacent."), bufsz);
3335 } else {
3336 fc_strlcat(buf, _("Must not be cardinally adjacent."), bufsz);
3337 }
3338 break;
3339 case 2:
3340 case 3:
3341 if (preq->present) {
3342 fc_strlcat(buf, _("Must be adjacent."), bufsz);
3343 } else {
3344 fc_strlcat(buf, _("Must not be adjacent."), bufsz);
3345 }
3346 break;
3347
3348 default:
3349 if (preq->present) {
3350 cat_snprintf(buf, bufsz,
3351 _("The squared distance between the tiles "
3352 "must be at most %d."),
3353 preq->source.value.distance_sq);
3354 } else {
3355 cat_snprintf(buf, bufsz,
3356 _("The squared distance between the tiles "
3357 "must be at least %d."),
3358 preq->source.value.distance_sq + 1);
3359 }
3360 break;
3361 }
3362 return TRUE;
3363 case REQ_RANGE_CADJACENT:
3364 case REQ_RANGE_ADJACENT:
3365 case REQ_RANGE_CITY:
3366 case REQ_RANGE_TRADE_ROUTE:
3367 case REQ_RANGE_CONTINENT:
3368 case REQ_RANGE_PLAYER:
3369 case REQ_RANGE_TEAM:
3370 case REQ_RANGE_ALLIANCE:
3371 case REQ_RANGE_WORLD:
3372 case REQ_RANGE_LOCAL:
3373 case REQ_RANGE_COUNT:
3374 /* Not supported. */
3375 break;
3376 }
3377 break;
3378
3379 case VUT_MAX_REGION_TILES:
3380 switch (preq->range) {
3381 case REQ_RANGE_CADJACENT:
3382 fc_strlcat(buf, prefix, bufsz);
3383 /* Off-by-one: The requirement counts the tile itself, we're phrasing
3384 * the helptext in terms of *other* tiles only. */
3385 if (preq->present) {
3386 if (preq->source.value.region_tiles == 1) {
3387 /* Special case for zero */
3388 fc_strlcat(buf,
3389 _("No other cardinally adjacent tile may be part of "
3390 "the same continent or ocean."),
3391 bufsz);
3392 } else {
3393 cat_snprintf(buf, bufsz,
3394 PL_("No more than %d other cardinally adjacent tile "
3395 "may be part of the same continent or ocean.",
3396 "No more than %d other cardinally adjacent tiles "
3397 "may be part of the same continent or ocean.",
3398 preq->source.value.region_tiles - 1),
3399 preq->source.value.region_tiles - 1);
3400 }
3401 } else {
3402 cat_snprintf(buf, bufsz,
3403 PL_("Requires at least %d other cardinally adjacent "
3404 "tile of the same continent or ocean.",
3405 "Requires at least %d other cardinally adjacent "
3406 "tiles of the same continent or ocean.",
3407 preq->source.value.region_tiles),
3408 preq->source.value.region_tiles);
3409 }
3410
3411 return TRUE;
3412 case REQ_RANGE_ADJACENT:
3413 fc_strlcat(buf, prefix, bufsz);
3414 /* Off-by-one: The requirement counts the tile itself, we're phrasing
3415 * the helptext in terms of *other* tiles only. */
3416 if (preq->present) {
3417 if (preq->source.value.region_tiles == 1) {
3418 /* Special case for zero */
3419 fc_strlcat(buf,
3420 _("No other adjacent tile may be part of the same "
3421 "continent or ocean."),
3422 bufsz);
3423 } else {
3424 cat_snprintf(buf, bufsz,
3425 PL_("No more than %d other adjacent tile may be "
3426 "part of the same continent or ocean.",
3427 "No more than %d other adjacent tiles may be "
3428 "part of the same continent or ocean.",
3429 preq->source.value.region_tiles - 1),
3430 preq->source.value.region_tiles - 1);
3431 }
3432 } else {
3433 cat_snprintf(buf, bufsz,
3434 PL_("Requires at least %d other adjacent tile of the "
3435 "same continent or ocean.",
3436 "Requires at least %d other adjacent tiles of the "
3437 "same continent or ocean.",
3438 preq->source.value.region_tiles),
3439 preq->source.value.region_tiles);
3440 }
3441
3442 return TRUE;
3443 case REQ_RANGE_CONTINENT:
3444 fc_strlcat(buf, prefix, bufsz);
3445 if (preq->present) {
3446 cat_snprintf(buf, bufsz,
3447 _("Requires a continent or ocean size of at most %d."),
3448 preq->source.value.region_tiles);
3449 } else {
3450 cat_snprintf(buf, bufsz,
3451 _("Requires a continent or ocean size of at least %d."),
3452 preq->source.value.region_tiles + 1);
3453 }
3454
3455 return TRUE;
3456 case REQ_RANGE_PLAYER:
3457 case REQ_RANGE_TEAM:
3458 case REQ_RANGE_ALLIANCE:
3459 case REQ_RANGE_WORLD:
3460 case REQ_RANGE_LOCAL:
3461 case REQ_RANGE_TILE:
3462 case REQ_RANGE_CITY:
3463 case REQ_RANGE_TRADE_ROUTE:
3464 case REQ_RANGE_COUNT:
3465 /* Not supported. */
3466 break;
3467 }
3468 break;
3469
3470 case VUT_TILE_REL:
3471 switch (preq->source.value.tilerel) {
3472 case TREL_SAME_TCLASS:
3473 switch (preq->range) {
3474 case REQ_RANGE_TILE:
3475 fc_strlcat(buf, prefix, bufsz);
3476 if (preq->present) {
3477 fc_strlcat(buf, _("Must be on the same terrain class."),
3478 bufsz);
3479 } else {
3480 fc_strlcat(buf, _("Must be on a different terrain class."),
3481 bufsz);
3482 }
3483 return TRUE;
3484 case REQ_RANGE_CADJACENT:
3485 fc_strlcat(buf, prefix, bufsz);
3486 if (preq->present) {
3487 fc_strlcat(buf, _("Must be cardinally adjacent to the same "
3488 "terrain class."),
3489 bufsz);
3490 } else {
3491 fc_strlcat(buf, _("Must not be cardinally adjacent to the same "
3492 "terrain class."),
3493 bufsz);
3494 }
3495 return TRUE;
3496 case REQ_RANGE_ADJACENT:
3497 fc_strlcat(buf, prefix, bufsz);
3498 if (preq->present) {
3499 fc_strlcat(buf, _("Must be adjacent to the same terrain class."),
3500 bufsz);
3501 } else {
3502 fc_strlcat(buf, _("Must not be adjacent to the same terrain "
3503 "class."),
3504 bufsz);
3505 }
3506 return TRUE;
3507 case REQ_RANGE_CITY:
3508 case REQ_RANGE_TRADE_ROUTE:
3509 case REQ_RANGE_CONTINENT:
3510 case REQ_RANGE_PLAYER:
3511 case REQ_RANGE_TEAM:
3512 case REQ_RANGE_ALLIANCE:
3513 case REQ_RANGE_WORLD:
3514 case REQ_RANGE_LOCAL:
3515 case REQ_RANGE_COUNT:
3516 /* Not supported. */
3517 break;
3518 }
3519 break;
3520 case TREL_SAME_REGION:
3521 switch (preq->range) {
3522 case REQ_RANGE_TILE:
3523 fc_strlcat(buf, prefix, bufsz);
3524 if (preq->present) {
3525 fc_strlcat(buf, _("Must be on the same continent or ocean."),
3526 bufsz);
3527 } else {
3528 fc_strlcat(buf, _("Must be on a different continent or ocean."),
3529 bufsz);
3530 }
3531 return TRUE;
3532 case REQ_RANGE_CADJACENT:
3533 fc_strlcat(buf, prefix, bufsz);
3534 if (preq->present) {
3535 fc_strlcat(buf, _("Must be cardinally adjacent to the same "
3536 "continent or ocean."),
3537 bufsz);
3538 } else {
3539 fc_strlcat(buf, _("Must not be cardinally adjacent to the same "
3540 "continent or ocean."),
3541 bufsz);
3542 }
3543 return TRUE;
3544 case REQ_RANGE_ADJACENT:
3545 fc_strlcat(buf, prefix, bufsz);
3546 if (preq->present) {
3547 fc_strlcat(buf, _("Must be adjacent to the same continent or "
3548 "ocean."),
3549 bufsz);
3550 } else {
3551 fc_strlcat(buf, _("Must not be adjacent to the same continent "
3552 "or ocean."),
3553 bufsz);
3554 }
3555 return TRUE;
3556 case REQ_RANGE_CITY:
3557 case REQ_RANGE_TRADE_ROUTE:
3558 case REQ_RANGE_CONTINENT:
3559 case REQ_RANGE_PLAYER:
3560 case REQ_RANGE_TEAM:
3561 case REQ_RANGE_ALLIANCE:
3562 case REQ_RANGE_WORLD:
3563 case REQ_RANGE_LOCAL:
3564 case REQ_RANGE_COUNT:
3565 /* Not supported. */
3566 break;
3567 }
3568 break;
3569 case TREL_ONLY_OTHER_REGION:
3570 switch (preq->range) {
3571 case REQ_RANGE_CADJACENT:
3572 fc_strlcat(buf, prefix, bufsz);
3573 if (preq->present) {
3574 fc_strlcat(buf, _("May only be cardinally adjacent to this "
3575 "other continent or ocean."),
3576 bufsz);
3577 } else {
3578 fc_strlcat(buf, _("Must be cardinally adjacent to more than "
3579 "just this other continent or ocean."),
3580 bufsz);
3581 }
3582 return TRUE;
3583 case REQ_RANGE_ADJACENT:
3584 fc_strlcat(buf, prefix, bufsz);
3585 if (preq->present) {
3586 fc_strlcat(buf, _("May only be adjacent to this other continent "
3587 "or ocean."),
3588 bufsz);
3589 } else {
3590 fc_strlcat(buf, _("Must be adjacent to more than just this "
3591 "other continent or ocean."),
3592 bufsz);
3593 }
3594 return TRUE;
3595 case REQ_RANGE_CITY:
3596 case REQ_RANGE_TRADE_ROUTE:
3597 case REQ_RANGE_CONTINENT:
3598 case REQ_RANGE_PLAYER:
3599 case REQ_RANGE_TEAM:
3600 case REQ_RANGE_ALLIANCE:
3601 case REQ_RANGE_WORLD:
3602 case REQ_RANGE_LOCAL:
3603 case REQ_RANGE_TILE:
3604 case REQ_RANGE_COUNT:
3605 /* Not supported. */
3606 break;
3607 }
3608 break;
3609 case TREL_REGION_SURROUNDED:
3610 switch (preq->range) {
3611 case REQ_RANGE_TILE:
3612 fc_strlcat(buf, prefix, bufsz);
3613 if (preq->present) {
3614 fc_strlcat(buf, _("Must be on a lake or island surrounded by "
3615 "this continent or ocean."),
3616 bufsz);
3617 } else {
3618 fc_strlcat(buf, _("Must not be on a lake or island surrounded "
3619 "by this continent or ocean."),
3620 bufsz);
3621 }
3622 return TRUE;
3623 case REQ_RANGE_CADJACENT:
3624 fc_strlcat(buf, prefix, bufsz);
3625 if (preq->present) {
3626 fc_strlcat(buf, _("Must be on or cardinally adjacent to a lake "
3627 "or island surrounded by this continent or "
3628 "ocean."),
3629 bufsz);
3630 } else {
3631 fc_strlcat(buf, _("Must not be on nor cardinally adjacent to a "
3632 "lake or island surrounded by this continent "
3633 "or ocean."),
3634 bufsz);
3635 }
3636 return TRUE;
3637 case REQ_RANGE_ADJACENT:
3638 fc_strlcat(buf, prefix, bufsz);
3639 if (preq->present) {
3640 fc_strlcat(buf, _("Must be on or adjacent to a lake or island "
3641 "surrounded by this continent or ocean."),
3642 bufsz);
3643 } else {
3644 fc_strlcat(buf, _("Must not be on nor adjacent to a lake or "
3645 "island surrounded by this continent or "
3646 "ocean."),
3647 bufsz);
3648 }
3649 return TRUE;
3650 case REQ_RANGE_CITY:
3651 case REQ_RANGE_TRADE_ROUTE:
3652 case REQ_RANGE_CONTINENT:
3653 case REQ_RANGE_PLAYER:
3654 case REQ_RANGE_TEAM:
3655 case REQ_RANGE_ALLIANCE:
3656 case REQ_RANGE_WORLD:
3657 case REQ_RANGE_LOCAL:
3658 case REQ_RANGE_COUNT:
3659 /* Not supported. */
3660 break;
3661 }
3662 break;
3663
3664 case TREL_COUNT:
3665 /* Invalid. */
3666 break;
3667 }
3668 break;
3669
3670 case VUT_COUNT:
3671 break;
3672 }
3673
3674 if (verb == VERB_DEFAULT) {
3675 char text[256];
3676
3677 log_error("%s requirement %s in range %d is not supported in reqtext.c.",
3678 preq->present ? "Present" : "Absent",
3679 universal_name_translation(&preq->source, text, sizeof(text)),
3680 preq->range);
3681 }
3682
3683 return FALSE;
3684}
3685
3686/*************************************************************/
3689bool req_text_insert_nl(char *buf, size_t bufsz, struct player *pplayer,
3690 const struct requirement *preq,
3691 enum rt_verbosity verb, const char *prefix)
3692{
3693 if (req_text_insert(buf, bufsz, pplayer, preq, verb, prefix)) {
3694 fc_strlcat(buf, "\n", bufsz);
3695
3696 return TRUE;
3697 }
3698
3699 return FALSE;
3700}
achievement_name_translation
const char * achievement_name_translation(struct achievement *pach)
Definition achievements.c:106
action_name_translation
const char * action_name_translation(const struct action *paction)
Definition actions.c:1230
astr_free
void astr_free(struct astring *astr)
Definition astring.c:148
astr_build_or_list
const char * astr_build_or_list(struct astring *astr, const char *const *items, size_t number)
Definition astring.c:313
astr_str
static const char * astr_str(const struct astring *astr) fc__attribute((nonnull(1)))
Definition astring.h:93
ASTRING_INIT
#define ASTRING_INIT
Definition astring.h:44
textcalfrag
const char * textcalfrag(int frag)
Definition calendar.c:101
textyear
const char * textyear(int year)
Definition calendar.c:121
get_output_name
const char * get_output_name(Output_type_id output)
Definition city.c:629
list
static struct fc_sockaddr_list * list
Definition clinet.c:102
incite_cost
char * incite_cost
Definition comments.c:76
counter_rule_name
const char * counter_rule_name(struct counter *pcount)
Definition counters.c:165
extra_name_translation
const char * extra_name_translation(const struct extra_type *pextra)
Definition extras.c:194
Q_
#define Q_(String)
Definition fcintl.h:70
PL_
#define PL_(String1, String2, n)
Definition fcintl.h:71
_
#define _(String)
Definition fcintl.h:67
government_name_translation
const char * government_name_translation(const struct government *pgovern)
Definition government.c:143
bufsz
static const int bufsz
Definition helpdlg.c:70
can_improvement_go_obsolete
bool can_improvement_go_obsolete(const struct impr_type *pimprove)
Definition improvement.c:403
is_wonder
bool is_wonder(const struct impr_type *pimprove)
Definition improvement.c:343
is_great_wonder
bool is_great_wonder(const struct impr_type *pimprove)
Definition improvement.c:780
improvement_name_translation
const char * improvement_name_translation(const struct impr_type *pimprove)
Definition improvement.c:243
fc_assert_msg
#define fc_assert_msg(condition, message,...)
Definition log.h:182
fc_assert
#define fc_assert(condition)
Definition log.h:177
log_error
#define log_error(message,...)
Definition log.h:104
move_points_text
const char * move_points_text(int mp, bool reduce)
Definition movement.c:1016
nation_adjective_translation
const char * nation_adjective_translation(const struct nation_type *pnation)
Definition nation.c:149
nation_group_name_translation
const char * nation_group_name_translation(const struct nation_group *pgroup)
Definition nation.c:1090
nation_plural_translation
const char * nation_plural_translation(const struct nation_type *pnation)
Definition nation.c:159
diplrel_name_translation
const char * diplrel_name_translation(int value)
Definition player.c:1631
req_text_insert_nl
bool req_text_insert_nl(char *buf, size_t bufsz, struct player *pplayer, const struct requirement *preq, enum rt_verbosity verb, const char *prefix)
Definition reqtext.c:3689
req_text_insert
bool req_text_insert(char *buf, size_t bufsz, struct player *pplayer, const struct requirement *preq, enum rt_verbosity verb, const char *prefix)
Definition reqtext.c:48
rt_verbosity
rt_verbosity
Definition reqtext.h:20
VERB_ACTUAL
@ VERB_ACTUAL
Definition reqtext.h:20
VERB_DEFAULT
@ VERB_DEFAULT
Definition reqtext.h:20
universal_name_translation
const char * universal_name_translation(const struct universal *psource, char *buf, size_t bufsz)
Definition requirements.c:7634
ssetv_human_readable
const char * ssetv_human_readable(ssetv val, bool present)
Definition server_settings.c:181
server_settings.h
specialist_plural_translation
const char * specialist_plural_translation(const struct specialist *sp)
Definition specialist.c:155
style_name_translation
const char * style_name_translation(const struct nation_style *pstyle)
Definition style.c:99
fc_strlcat
size_t fc_strlcat(char *dest, const char *src, size_t n)
Definition support.c:822
cat_snprintf
int cat_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:986
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
advance_name_translation
const char * advance_name_translation(const struct advance *padvance)
Definition tech.c:300
terrain_class_name_translation
const char * terrain_class_name_translation(enum terrain_class tclass)
Definition terrain.c:661
terrain_name_translation
const char * terrain_name_translation(const struct terrain *pterrain)
Definition terrain.c:238
terrain_type_terrain_class
enum terrain_class terrain_type_terrain_class(const struct terrain *pterrain)
Definition terrain.c:582
terrain_type_iterate
#define terrain_type_iterate(_p)
Definition terrain.h:266
terrain_type_iterate_end
#define terrain_type_iterate_end
Definition terrain.h:272
terrain_has_flag
#define terrain_has_flag(terr, flag)
Definition terrain.h:176
goods_name_translation
const char * goods_name_translation(struct goods_type *pgood)
Definition traderoutes.c:631
uclass_name_translation
const char * uclass_name_translation(const struct unit_class *pclass)
Definition unittype.c:1638
uclass_count
Unit_Class_id uclass_count(void)
Definition unittype.c:2452
utype_name_translation
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1566
role_units_translations
bool role_units_translations(struct astring *astr, int flag, bool alts)
Definition unittype.c:1674
uclass_has_flag
static bool uclass_has_flag(const struct unit_class *punitclass, enum unit_class_flag_id flag)
Definition unittype.h:773
unit_class_iterate
#define unit_class_iterate(_p)
Definition unittype.h:915
unit_class_iterate_end
#define unit_class_iterate_end
Definition unittype.h:922
Generated on Sun Dec 22 2024 22:30:37 for Freeciv-3.3 by doxygen 1.9.8