Freeciv-3.4
Loading...
Searching...
No Matches
actions.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996-2013 - Freeciv Development 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#include <math.h> /* ceil(), floor() */
19
20/* utility */
21#include "astring.h"
22
23/* common */
24#include "actions.h"
25#include "city.h"
26#include "combat.h"
27#include "fc_interface.h"
28#include "game.h"
29#include "map.h"
30#include "metaknowledge.h"
31#include "movement.h"
32#include "oblig_reqs.h"
33#include "research.h"
34#include "server_settings.h"
35#include "specialist.h"
36#include "unit.h"
37
38
39/* Values used to interpret action probabilities.
40 *
41 * Action probabilities are sent over the network. A change in a value here
42 * will therefore change the network protocol.
43 *
44 * A change in a value here should also update the action probability
45 * format documentation in fc_types.h */
46/* The lowest possible probability value (0%) */
47#define ACTPROB_VAL_MIN 0
48/* The highest possible probability value (100%) */
49#define ACTPROB_VAL_MAX 200
50/* A probability increase of 1% corresponds to this increase. */
51#define ACTPROB_VAL_1_PCT (ACTPROB_VAL_MAX / 100)
52/* Action probability doesn't apply when min is this. */
53#define ACTPROB_VAL_NA 253
54/* Action probability unsupported when min is this. */
55#define ACTPROB_VAL_NOT_IMPL 254
56
57static struct action *actions[MAX_NUM_ACTIONS];
58struct action **_actions = actions;
59struct action_auto_perf auto_perfs[MAX_NUM_ACTION_AUTO_PERFORMERS];
60static bool actions_initialized = FALSE;
61
62static struct action_enabler_list *action_enablers_by_action[MAX_NUM_ACTIONS];
63
64static struct astring ui_name_str = ASTRING_INIT;
65
66static struct action *
67unit_action_new(action_id id,
68 enum action_result result,
69 bool rare_pop_up,
70 bool unitwaittime_controlled,
71 enum moves_actor_kind moves_actor,
72 const int min_distance,
73 const int max_distance,
74 bool actor_consuming_always);
75static struct action *
76player_action_new(action_id id,
77 enum action_result result);
78static struct action *
79city_action_new(action_id id,
80 enum action_result result);
81
82static bool is_enabler_active(const struct action_enabler *enabler,
83 const struct req_context *actor,
84 const struct req_context *target);
85
86static inline bool
87action_prob_is_signal(const struct act_prob probability);
88static inline bool
89action_prob_not_relevant(const struct act_prob probability);
90static inline bool
91action_prob_not_impl(const struct act_prob probability);
92
93static struct act_prob ap_diplomat_battle(const struct unit *pattacker,
94 const struct unit *pvictim,
95 const struct tile *tgt_tile,
96 const struct action *paction)
97 fc__attribute((nonnull(3)));
98
99/* Make sure that an action distance can target the whole map. */
100FC_STATIC_ASSERT(MAP_DISTANCE_MAX <= ACTION_DISTANCE_LAST_NON_SIGNAL,
101 action_range_can_not_cover_the_whole_map);
102
103static struct action_list *actlist_by_result[ACTRES_LAST];
104static struct action_list *actlist_by_activity[ACTIVITY_LAST];
105
106
107/**********************************************************************/
110static void hard_code_actions(void)
111{
112 actions[ACTION_SPY_POISON] =
113 unit_action_new(ACTION_SPY_POISON, ACTRES_SPY_POISON,
114 FALSE, TRUE,
115 MAK_ESCAPE, 0, 1, TRUE);
116 actions[ACTION_SPY_POISON_ESC] =
117 unit_action_new(ACTION_SPY_POISON_ESC, ACTRES_SPY_POISON,
118 FALSE, TRUE,
119 MAK_ESCAPE, 0, 1, FALSE);
120 actions[ACTION_SPY_SABOTAGE_UNIT] =
121 unit_action_new(ACTION_SPY_SABOTAGE_UNIT, ACTRES_SPY_SABOTAGE_UNIT,
122 FALSE, TRUE,
123 MAK_ESCAPE, 0, 1, TRUE);
124 actions[ACTION_SPY_SABOTAGE_UNIT_ESC] =
125 unit_action_new(ACTION_SPY_SABOTAGE_UNIT_ESC, ACTRES_SPY_SABOTAGE_UNIT,
126 FALSE, TRUE,
127 MAK_ESCAPE, 0, 1, FALSE);
128 actions[ACTION_SPY_BRIBE_UNIT] =
129 unit_action_new(ACTION_SPY_BRIBE_UNIT, ACTRES_SPY_BRIBE_UNIT,
130 FALSE, TRUE,
131 /* Tries a forced move if the target unit is alone at
132 * its tile and not in a city. Takes all movement if
133 * the forced move fails. */
134 MAK_FORCED,
135 0, 1, FALSE);
136 actions[ACTION_SPY_BRIBE_STACK] =
137 unit_action_new(ACTION_SPY_BRIBE_STACK, ACTRES_SPY_BRIBE_STACK,
138 FALSE, TRUE,
139 MAK_FORCED,
140 0, 1, FALSE);
141 actions[ACTION_SPY_SABOTAGE_CITY] =
142 unit_action_new(ACTION_SPY_SABOTAGE_CITY, ACTRES_SPY_SABOTAGE_CITY,
143 FALSE, TRUE,
144 MAK_ESCAPE, 0, 1, TRUE);
145 actions[ACTION_SPY_SABOTAGE_CITY_ESC] =
146 unit_action_new(ACTION_SPY_SABOTAGE_CITY_ESC, ACTRES_SPY_SABOTAGE_CITY,
147 FALSE, TRUE,
148 MAK_ESCAPE, 0, 1, FALSE);
149 actions[ACTION_SPY_TARGETED_SABOTAGE_CITY] =
150 unit_action_new(ACTION_SPY_TARGETED_SABOTAGE_CITY,
151 ACTRES_SPY_TARGETED_SABOTAGE_CITY,
152 FALSE, TRUE,
153 MAK_ESCAPE, 0, 1, TRUE);
154 actions[ACTION_SPY_SABOTAGE_CITY_PRODUCTION] =
155 unit_action_new(ACTION_SPY_SABOTAGE_CITY_PRODUCTION,
156 ACTRES_SPY_SABOTAGE_CITY_PRODUCTION,
157 FALSE, TRUE,
158 MAK_ESCAPE, 0, 1, TRUE);
159 actions[ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC] =
160 unit_action_new(ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC,
161 ACTRES_SPY_TARGETED_SABOTAGE_CITY,
162 FALSE, TRUE,
163 MAK_ESCAPE, 0, 1, FALSE);
164 actions[ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC] =
165 unit_action_new(ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC,
166 ACTRES_SPY_SABOTAGE_CITY_PRODUCTION,
167 FALSE, TRUE,
168 MAK_ESCAPE, 0, 1, FALSE);
169 actions[ACTION_SPY_INCITE_CITY] =
170 unit_action_new(ACTION_SPY_INCITE_CITY, ACTRES_SPY_INCITE_CITY,
171 FALSE, TRUE,
172 MAK_ESCAPE, 0, 1, TRUE);
173 actions[ACTION_SPY_INCITE_CITY_ESC] =
174 unit_action_new(ACTION_SPY_INCITE_CITY_ESC, ACTRES_SPY_INCITE_CITY,
175 FALSE, TRUE,
176 MAK_ESCAPE, 0, 1, FALSE);
177 actions[ACTION_ESTABLISH_EMBASSY] =
178 unit_action_new(ACTION_ESTABLISH_EMBASSY,
179 ACTRES_ESTABLISH_EMBASSY,
180 FALSE, TRUE,
181 MAK_STAYS, 0, 1, FALSE);
182 actions[ACTION_ESTABLISH_EMBASSY_STAY] =
183 unit_action_new(ACTION_ESTABLISH_EMBASSY_STAY,
184 ACTRES_ESTABLISH_EMBASSY,
185 FALSE, TRUE,
186 MAK_STAYS, 0, 1, TRUE);
187 actions[ACTION_SPY_STEAL_TECH] =
188 unit_action_new(ACTION_SPY_STEAL_TECH,
189 ACTRES_SPY_STEAL_TECH,
190 FALSE, TRUE,
191 MAK_ESCAPE, 0, 1, TRUE);
192 actions[ACTION_SPY_STEAL_TECH_ESC] =
193 unit_action_new(ACTION_SPY_STEAL_TECH_ESC,
194 ACTRES_SPY_STEAL_TECH,
195 FALSE, TRUE,
196 MAK_ESCAPE, 0, 1, FALSE);
197 actions[ACTION_SPY_TARGETED_STEAL_TECH] =
198 unit_action_new(ACTION_SPY_TARGETED_STEAL_TECH,
199 ACTRES_SPY_TARGETED_STEAL_TECH,
200 FALSE, TRUE,
201 MAK_ESCAPE, 0, 1, TRUE);
202 actions[ACTION_SPY_TARGETED_STEAL_TECH_ESC] =
203 unit_action_new(ACTION_SPY_TARGETED_STEAL_TECH_ESC,
204 ACTRES_SPY_TARGETED_STEAL_TECH,
205 FALSE, TRUE,
206 MAK_ESCAPE, 0, 1, FALSE);
207 actions[ACTION_SPY_INVESTIGATE_CITY] =
208 unit_action_new(ACTION_SPY_INVESTIGATE_CITY,
209 ACTRES_SPY_INVESTIGATE_CITY,
210 FALSE, TRUE,
211 MAK_STAYS, 0, 1, FALSE);
212 actions[ACTION_INV_CITY_SPEND] =
213 unit_action_new(ACTION_INV_CITY_SPEND,
214 ACTRES_SPY_INVESTIGATE_CITY,
215 FALSE, TRUE,
216 MAK_STAYS, 0, 1, TRUE);
217 actions[ACTION_SPY_STEAL_GOLD] =
218 unit_action_new(ACTION_SPY_STEAL_GOLD,
219 ACTRES_SPY_STEAL_GOLD,
220 FALSE, TRUE,
221 MAK_ESCAPE, 0, 1, TRUE);
222 actions[ACTION_SPY_STEAL_GOLD_ESC] =
223 unit_action_new(ACTION_SPY_STEAL_GOLD_ESC,
224 ACTRES_SPY_STEAL_GOLD,
225 FALSE, TRUE,
226 MAK_ESCAPE, 0, 1, FALSE);
227 actions[ACTION_SPY_SPREAD_PLAGUE] =
228 unit_action_new(ACTION_SPY_SPREAD_PLAGUE,
229 ACTRES_SPY_SPREAD_PLAGUE,
230 FALSE, TRUE,
231 MAK_ESCAPE, 0, 1, FALSE);
232 actions[ACTION_SPY_ESCAPE] =
233 unit_action_new(ACTION_SPY_ESCAPE,
234 ACTRES_SPY_ESCAPE,
235 FALSE, TRUE,
236 MAK_ESCAPE, 0, 1, FALSE);
237 actions[ACTION_TRADE_ROUTE] =
238 unit_action_new(ACTION_TRADE_ROUTE, ACTRES_TRADE_ROUTE,
239 FALSE, TRUE,
240 MAK_STAYS, 0, 1, TRUE);
241 actions[ACTION_MARKETPLACE] =
242 unit_action_new(ACTION_MARKETPLACE, ACTRES_MARKETPLACE,
243 FALSE, TRUE,
244 MAK_STAYS, 0, 1, TRUE);
245 actions[ACTION_HELP_WONDER] =
246 unit_action_new(ACTION_HELP_WONDER, ACTRES_HELP_WONDER,
247 FALSE, TRUE,
248 MAK_STAYS, 0, 1, TRUE);
249 actions[ACTION_CAPTURE_UNITS] =
250 unit_action_new(ACTION_CAPTURE_UNITS, ACTRES_CAPTURE_UNITS,
251 FALSE, TRUE, MAK_STAYS,
252 /* A single domestic unit at the target tile will make
253 * the action illegal. It must therefore be performed
254 * from another tile. */
255 1, 1,
256 FALSE);
257 actions[ACTION_FOUND_CITY] =
258 unit_action_new(ACTION_FOUND_CITY, ACTRES_FOUND_CITY,
259 TRUE, TRUE, MAK_STAYS,
260 /* Illegal to perform to a target on another tile.
261 * Reason: The Freeciv code assumes that the city
262 * founding unit is located at the tile were the new
263 * city is founded. */
264 0, 0,
265 TRUE);
266 actions[ACTION_JOIN_CITY] =
267 unit_action_new(ACTION_JOIN_CITY, ACTRES_JOIN_CITY,
268 TRUE, TRUE,
269 MAK_STAYS, 0, 1, TRUE);
270 actions[ACTION_STEAL_MAPS] =
271 unit_action_new(ACTION_STEAL_MAPS, ACTRES_STEAL_MAPS,
272 FALSE, TRUE,
273 MAK_ESCAPE, 0, 1, TRUE);
274 actions[ACTION_STEAL_MAPS_ESC] =
275 unit_action_new(ACTION_STEAL_MAPS_ESC, ACTRES_STEAL_MAPS,
276 FALSE, TRUE,
277 MAK_ESCAPE, 0, 1, FALSE);
278 actions[ACTION_BOMBARD] =
279 unit_action_new(ACTION_BOMBARD, ACTRES_BOMBARD,
280 FALSE, TRUE, MAK_STAYS,
281 /* A single domestic unit at the target tile will make
282 * the action illegal. It must therefore be performed
283 * from another tile. */
284 1,
285 /* Overwritten by the ruleset's bombard_max_range */
286 1,
287 FALSE);
288 actions[ACTION_BOMBARD2] =
289 unit_action_new(ACTION_BOMBARD2, ACTRES_BOMBARD,
290 FALSE, TRUE,
291 MAK_STAYS,
292 /* A single domestic unit at the target tile will make
293 * the action illegal. It must therefore be performed
294 * from another tile. */
295 1,
296 /* Overwritten by the ruleset's bombard_2_max_range */
297 1,
298 FALSE);
299 actions[ACTION_BOMBARD3] =
300 unit_action_new(ACTION_BOMBARD3, ACTRES_BOMBARD,
301 FALSE, TRUE, MAK_STAYS,
302 /* A single domestic unit at the target tile will make
303 * the action illegal. It must therefore be performed
304 * from another tile. */
305 1,
306 /* Overwritten by the ruleset's bombard_3_max_range */
307 1,
308 FALSE);
309 actions[ACTION_BOMBARD4] =
310 unit_action_new(ACTION_BOMBARD4, ACTRES_BOMBARD,
311 FALSE, TRUE, MAK_STAYS,
312 /* A single domestic unit at the target tile will make
313 * the action illegal. It must therefore be performed
314 * from another tile. */
315 1,
316 /* Overwritten by the ruleset's bombard_4_max_range */
317 1,
318 FALSE);
319 actions[ACTION_BOMBARD_LETHAL] =
320 unit_action_new(ACTION_BOMBARD_LETHAL, ACTRES_BOMBARD,
321 FALSE, TRUE, MAK_STAYS,
322 /* A single domestic unit at the target tile will make
323 * the action illegal. It must therefore be performed
324 * from another tile. */
325 1,
326 /* Overwritten by the ruleset's bombard_lethal_max_range */
327 1,
328 FALSE);
329 actions[ACTION_BOMBARD_LETHAL2] =
330 unit_action_new(ACTION_BOMBARD_LETHAL2, ACTRES_BOMBARD,
331 FALSE, TRUE, MAK_STAYS,
332 /* A single domestic unit at the target tile will make
333 * the action illegal. It must therefore be performed
334 * from another tile. */
335 1,
336 /* Overwritten by the ruleset's bombard_lethal_2_max_range */
337 1,
338 FALSE);
339 actions[ACTION_SPY_NUKE] =
340 unit_action_new(ACTION_SPY_NUKE, ACTRES_SPY_NUKE,
341 FALSE, TRUE,
342 MAK_ESCAPE, 0, 1, TRUE);
343 actions[ACTION_SPY_NUKE_ESC] =
344 unit_action_new(ACTION_SPY_NUKE_ESC, ACTRES_SPY_NUKE,
345 FALSE, TRUE,
346 MAK_ESCAPE, 0, 1, FALSE);
347 actions[ACTION_NUKE] =
348 unit_action_new(ACTION_NUKE, ACTRES_NUKE,
349 TRUE, TRUE,
350 MAK_STAYS, 0,
351 /* Overwritten by the ruleset's
352 * explode_nuclear_max_range */
353 0,
354 TRUE);
355 actions[ACTION_NUKE_CITY] =
356 unit_action_new(ACTION_NUKE_CITY, ACTRES_NUKE,
357 TRUE, TRUE,
358 MAK_STAYS, 1, 1, TRUE);
359 actions[ACTION_NUKE_UNITS] =
360 unit_action_new(ACTION_NUKE_UNITS, ACTRES_NUKE_UNITS,
361 TRUE, TRUE,
362 MAK_STAYS, 1, 1, TRUE);
363 actions[ACTION_DESTROY_CITY] =
364 unit_action_new(ACTION_DESTROY_CITY, ACTRES_DESTROY_CITY,
365 TRUE, TRUE,
366 MAK_STAYS, 0, 1, FALSE);
367 actions[ACTION_EXPEL_UNIT] =
368 unit_action_new(ACTION_EXPEL_UNIT, ACTRES_EXPEL_UNIT,
369 FALSE, TRUE,
370 MAK_STAYS, 0, 1, FALSE);
371 actions[ACTION_DISBAND_UNIT_RECOVER] =
372 unit_action_new(ACTION_DISBAND_UNIT_RECOVER, ACTRES_DISBAND_UNIT_RECOVER,
373 TRUE, TRUE, MAK_STAYS,
374 /* Illegal to perform to a target on another tile to
375 * keep the rules exactly as they were for now. */
376 0, 1,
377 TRUE);
378 actions[ACTION_DISBAND_UNIT] =
379 unit_action_new(ACTION_DISBAND_UNIT,
380 /* Can't be ACTRES_NONE because
381 * action_success_actor_consume() sets unit lost
382 * reason based on action result. */
383 ACTRES_DISBAND_UNIT,
384 TRUE, TRUE,
385 MAK_STAYS, 0, 0, TRUE);
386 actions[ACTION_HOME_CITY] =
387 unit_action_new(ACTION_HOME_CITY, ACTRES_HOME_CITY,
388 TRUE, FALSE,
389 /* Illegal to perform to a target on another tile to
390 * keep the rules exactly as they were for now. */
391 MAK_STAYS, 0, 0, FALSE);
392 actions[ACTION_HOMELESS] =
393 unit_action_new(ACTION_HOMELESS, ACTRES_HOMELESS,
394 TRUE, FALSE,
395 MAK_STAYS, 0, 0, FALSE);
396 actions[ACTION_UPGRADE_UNIT] =
397 unit_action_new(ACTION_UPGRADE_UNIT, ACTRES_UPGRADE_UNIT,
398 TRUE, TRUE, MAK_STAYS,
399 /* Illegal to perform to a target on another tile to
400 * keep the rules exactly as they were for now. */
401 0, 0,
402 FALSE);
403 actions[ACTION_PARADROP] =
404 unit_action_new(ACTION_PARADROP, ACTRES_PARADROP,
405 TRUE, TRUE,
406 MAK_TELEPORT,
407 1,
408 /* Still limited by each unit type's
409 * paratroopers_range field. */
410 ACTION_DISTANCE_MAX,
411 FALSE);
412 actions[ACTION_PARADROP_CONQUER] =
413 unit_action_new(ACTION_PARADROP_CONQUER, ACTRES_PARADROP_CONQUER,
414 TRUE, TRUE,
415 MAK_TELEPORT,
416 1,
417 /* Still limited by each unit type's
418 * paratroopers_range field. */
419 ACTION_DISTANCE_MAX,
420 FALSE);
421 actions[ACTION_PARADROP_FRIGHTEN] =
422 unit_action_new(ACTION_PARADROP_FRIGHTEN, ACTRES_PARADROP,
423 TRUE, TRUE,
424 MAK_TELEPORT,
425 1,
426 /* Still limited by each unit type's
427 * paratroopers_range field. */
428 ACTION_DISTANCE_MAX,
429 FALSE);
430 actions[ACTION_PARADROP_FRIGHTEN_CONQUER] =
431 unit_action_new(ACTION_PARADROP_FRIGHTEN_CONQUER,
432 ACTRES_PARADROP_CONQUER,
433 TRUE, TRUE,
434 MAK_TELEPORT,
435 1,
436 /* Still limited by each unit type's
437 * paratroopers_range field. */
438 ACTION_DISTANCE_MAX,
439 FALSE);
440 actions[ACTION_PARADROP_ENTER] =
441 unit_action_new(ACTION_PARADROP_ENTER, ACTRES_PARADROP,
442 TRUE, TRUE,
443 MAK_TELEPORT,
444 1,
445 /* Still limited by each unit type's
446 * paratroopers_range field. */
447 ACTION_DISTANCE_MAX,
448 FALSE);
449 actions[ACTION_PARADROP_ENTER_CONQUER] =
450 unit_action_new(ACTION_PARADROP_ENTER_CONQUER,
451 ACTRES_PARADROP_CONQUER,
452 TRUE, TRUE,
453 MAK_TELEPORT,
454 1,
455 /* Still limited by each unit type's
456 * paratroopers_range field. */
457 ACTION_DISTANCE_MAX,
458 FALSE);
459 actions[ACTION_AIRLIFT] =
460 unit_action_new(ACTION_AIRLIFT, ACTRES_AIRLIFT,
461 TRUE, TRUE,
462 MAK_TELEPORT,
463 1,
464 /* Overwritten by the ruleset's airlift_max_range. */
465 ACTION_DISTANCE_UNLIMITED,
466 FALSE);
467 actions[ACTION_ATTACK] =
468 unit_action_new(ACTION_ATTACK, ACTRES_ATTACK,
469 FALSE, TRUE,
470 /* Tries a forced move if the target unit's tile has
471 * no non-allied units and the occupychance dice roll
472 * tells it to move. */
473 MAK_FORCED,
474 1, 1, FALSE);
475 actions[ACTION_ATTACK2] =
476 unit_action_new(ACTION_ATTACK2, ACTRES_ATTACK,
477 FALSE, TRUE,
478 /* Tries a forced move if the target unit's tile has
479 * no non-allied units and the occupychance dice roll
480 * tells it to move. */
481 MAK_FORCED,
482 1, 1, FALSE);
483 actions[ACTION_SUICIDE_ATTACK] =
484 unit_action_new(ACTION_SUICIDE_ATTACK, ACTRES_ATTACK,
485 FALSE, TRUE,
486 MAK_FORCED, 1, 1, TRUE);
487 actions[ACTION_SUICIDE_ATTACK2] =
488 unit_action_new(ACTION_SUICIDE_ATTACK2, ACTRES_ATTACK,
489 FALSE, TRUE,
490 MAK_FORCED, 1, 1, TRUE);
491 actions[ACTION_WIPE_UNITS] =
492 unit_action_new(ACTION_WIPE_UNITS, ACTRES_WIPE_UNITS,
493 FALSE, TRUE,
494 MAK_FORCED,
495 1, 1, FALSE);
496 actions[ACTION_STRIKE_BUILDING] =
497 unit_action_new(ACTION_STRIKE_BUILDING, ACTRES_STRIKE_BUILDING,
498 FALSE, FALSE,
499 MAK_STAYS, 1, 1, FALSE);
500 actions[ACTION_STRIKE_PRODUCTION] =
501 unit_action_new(ACTION_STRIKE_PRODUCTION, ACTRES_STRIKE_PRODUCTION,
502 FALSE, FALSE,
503 MAK_STAYS, 1, 1, FALSE);
504 actions[ACTION_CONQUER_CITY_SHRINK] =
505 unit_action_new(ACTION_CONQUER_CITY_SHRINK, ACTRES_CONQUER_CITY,
506 FALSE, TRUE,
507 MAK_REGULAR, 1, 1, FALSE);
508 actions[ACTION_CONQUER_CITY_SHRINK2] =
509 unit_action_new(ACTION_CONQUER_CITY_SHRINK2, ACTRES_CONQUER_CITY,
510 FALSE, TRUE,
511 MAK_REGULAR, 1, 1, FALSE);
512 actions[ACTION_CONQUER_CITY_SHRINK3] =
513 unit_action_new(ACTION_CONQUER_CITY_SHRINK3, ACTRES_CONQUER_CITY,
514 FALSE, TRUE,
515 MAK_REGULAR, 1, 1, FALSE);
516 actions[ACTION_CONQUER_CITY_SHRINK4] =
517 unit_action_new(ACTION_CONQUER_CITY_SHRINK4, ACTRES_CONQUER_CITY,
518 FALSE, TRUE,
519 MAK_REGULAR, 1, 1, FALSE);
520 actions[ACTION_CONQUER_EXTRAS] =
521 unit_action_new(ACTION_CONQUER_EXTRAS, ACTRES_CONQUER_EXTRAS,
522 FALSE, TRUE,
523 MAK_REGULAR, 1, 1, FALSE);
524 actions[ACTION_CONQUER_EXTRAS2] =
525 unit_action_new(ACTION_CONQUER_EXTRAS2, ACTRES_CONQUER_EXTRAS,
526 FALSE, TRUE,
527 MAK_REGULAR, 1, 1, FALSE);
528 actions[ACTION_CONQUER_EXTRAS3] =
529 unit_action_new(ACTION_CONQUER_EXTRAS3, ACTRES_CONQUER_EXTRAS,
530 FALSE, TRUE,
531 MAK_REGULAR, 1, 1, FALSE);
532 actions[ACTION_CONQUER_EXTRAS4] =
533 unit_action_new(ACTION_CONQUER_EXTRAS4, ACTRES_CONQUER_EXTRAS,
534 FALSE, TRUE,
535 MAK_REGULAR, 1, 1, FALSE);
536 actions[ACTION_HEAL_UNIT] =
537 unit_action_new(ACTION_HEAL_UNIT, ACTRES_HEAL_UNIT,
538 FALSE, TRUE,
539 MAK_STAYS, 0, 1, FALSE);
540 actions[ACTION_HEAL_UNIT2] =
541 unit_action_new(ACTION_HEAL_UNIT2, ACTRES_HEAL_UNIT,
542 FALSE, TRUE,
543 MAK_STAYS, 0, 1, FALSE);
544 actions[ACTION_TRANSFORM_TERRAIN] =
545 unit_action_new(ACTION_TRANSFORM_TERRAIN, ACTRES_TRANSFORM_TERRAIN,
546 TRUE, FALSE,
547 MAK_STAYS, 0, 0, FALSE);
548 actions[ACTION_TRANSFORM_TERRAIN2] =
549 unit_action_new(ACTION_TRANSFORM_TERRAIN2, ACTRES_TRANSFORM_TERRAIN,
550 TRUE, FALSE,
551 MAK_STAYS, 0, 0, FALSE);
552 actions[ACTION_CULTIVATE] =
553 unit_action_new(ACTION_CULTIVATE, ACTRES_CULTIVATE,
554 TRUE, FALSE,
555 MAK_STAYS, 0, 0, FALSE);
556 actions[ACTION_CULTIVATE2] =
557 unit_action_new(ACTION_CULTIVATE2, ACTRES_CULTIVATE,
558 TRUE, FALSE,
559 MAK_STAYS, 0, 0, FALSE);
560 actions[ACTION_PLANT] =
561 unit_action_new(ACTION_PLANT, ACTRES_PLANT,
562 TRUE, FALSE,
563 MAK_STAYS, 0, 0, FALSE);
564 actions[ACTION_PLANT2] =
565 unit_action_new(ACTION_PLANT2, ACTRES_PLANT,
566 TRUE, FALSE,
567 MAK_STAYS, 0, 0, FALSE);
568 actions[ACTION_PILLAGE] =
569 unit_action_new(ACTION_PILLAGE, ACTRES_PILLAGE,
570 TRUE, FALSE,
571 MAK_STAYS, 0, 0, FALSE);
572 actions[ACTION_PILLAGE2] =
573 unit_action_new(ACTION_PILLAGE2, ACTRES_PILLAGE,
574 TRUE, FALSE,
575 MAK_STAYS, 0, 0, FALSE);
576 actions[ACTION_CLEAN] =
577 unit_action_new(ACTION_CLEAN, ACTRES_CLEAN,
578 TRUE, FALSE,
579 MAK_STAYS, 0, 0, FALSE);
580 actions[ACTION_CLEAN2] =
581 unit_action_new(ACTION_CLEAN2, ACTRES_CLEAN,
582 TRUE, FALSE,
583 MAK_STAYS, 0, 0, FALSE);
584 actions[ACTION_FORTIFY] =
585 unit_action_new(ACTION_FORTIFY, ACTRES_FORTIFY,
586 TRUE, FALSE,
587 MAK_STAYS, 0, 0, FALSE);
588 actions[ACTION_FORTIFY2] =
589 unit_action_new(ACTION_FORTIFY2, ACTRES_FORTIFY,
590 TRUE, FALSE,
591 MAK_STAYS, 0, 0, FALSE);
592 actions[ACTION_ROAD] =
593 unit_action_new(ACTION_ROAD, ACTRES_ROAD,
594 TRUE, FALSE,
595 MAK_STAYS, 0, 0, FALSE);
596 actions[ACTION_ROAD2] =
597 unit_action_new(ACTION_ROAD2, ACTRES_ROAD,
598 TRUE, FALSE,
599 MAK_STAYS, 0, 0, FALSE);
600 actions[ACTION_CONVERT] =
601 unit_action_new(ACTION_CONVERT, ACTRES_CONVERT,
602 TRUE, FALSE,
603 MAK_STAYS, 0, 0, FALSE);
604 actions[ACTION_BASE] =
605 unit_action_new(ACTION_BASE, ACTRES_BASE,
606 TRUE, FALSE,
607 MAK_STAYS, 0, 0, FALSE);
608 actions[ACTION_BASE2] =
609 unit_action_new(ACTION_BASE2, ACTRES_BASE,
610 TRUE, FALSE,
611 MAK_STAYS, 0, 0, FALSE);
612 actions[ACTION_MINE] =
613 unit_action_new(ACTION_MINE, ACTRES_MINE,
614 TRUE, FALSE,
615 MAK_STAYS, 0, 0, FALSE);
616 actions[ACTION_MINE2] =
617 unit_action_new(ACTION_MINE2, ACTRES_MINE,
618 TRUE, FALSE,
619 MAK_STAYS, 0, 0, FALSE);
620 actions[ACTION_IRRIGATE] =
621 unit_action_new(ACTION_IRRIGATE, ACTRES_IRRIGATE,
622 TRUE, FALSE,
623 MAK_STAYS, 0, 0, FALSE);
624 actions[ACTION_IRRIGATE2] =
625 unit_action_new(ACTION_IRRIGATE2, ACTRES_IRRIGATE,
626 TRUE, FALSE,
627 MAK_STAYS, 0, 0, FALSE);
628 actions[ACTION_TRANSPORT_DEBOARD] =
629 unit_action_new(ACTION_TRANSPORT_DEBOARD, ACTRES_TRANSPORT_DEBOARD,
630 TRUE, FALSE,
631 MAK_STAYS, 0, 0, FALSE);
632 actions[ACTION_TRANSPORT_BOARD] =
633 unit_action_new(ACTION_TRANSPORT_BOARD, ACTRES_TRANSPORT_BOARD,
634 TRUE, FALSE,
635 MAK_STAYS, 0, 0, FALSE);
636 actions[ACTION_TRANSPORT_BOARD2] =
637 unit_action_new(ACTION_TRANSPORT_BOARD2, ACTRES_TRANSPORT_BOARD,
638 TRUE, FALSE,
639 MAK_STAYS, 0, 0, FALSE);
640 actions[ACTION_TRANSPORT_BOARD3] =
641 unit_action_new(ACTION_TRANSPORT_BOARD3, ACTRES_TRANSPORT_BOARD,
642 TRUE, FALSE,
643 MAK_STAYS, 0, 0, FALSE);
644 actions[ACTION_TRANSPORT_UNLOAD] =
645 unit_action_new(ACTION_TRANSPORT_UNLOAD, ACTRES_TRANSPORT_UNLOAD,
646 TRUE, FALSE,
647 MAK_STAYS, 0, 0, FALSE);
648 actions[ACTION_TRANSPORT_LOAD] =
649 unit_action_new(ACTION_TRANSPORT_LOAD, ACTRES_TRANSPORT_LOAD,
650 TRUE, FALSE,
651 MAK_STAYS, 0, 0, FALSE);
652 actions[ACTION_TRANSPORT_LOAD2] =
653 unit_action_new(ACTION_TRANSPORT_LOAD2, ACTRES_TRANSPORT_LOAD,
654 TRUE, FALSE,
655 MAK_STAYS, 0, 0, FALSE);
656 actions[ACTION_TRANSPORT_LOAD3] =
657 unit_action_new(ACTION_TRANSPORT_LOAD3, ACTRES_TRANSPORT_LOAD,
658 TRUE, FALSE,
659 MAK_STAYS, 0, 0, FALSE);
660 actions[ACTION_TRANSPORT_DISEMBARK1] =
661 unit_action_new(ACTION_TRANSPORT_DISEMBARK1,
662 ACTRES_TRANSPORT_DISEMBARK,
663 FALSE, TRUE,
664 MAK_REGULAR, 1, 1, FALSE);
665 actions[ACTION_TRANSPORT_DISEMBARK2] =
666 unit_action_new(ACTION_TRANSPORT_DISEMBARK2,
667 ACTRES_TRANSPORT_DISEMBARK,
668 FALSE, TRUE,
669 MAK_REGULAR, 1, 1, FALSE);
670 actions[ACTION_TRANSPORT_DISEMBARK3] =
671 unit_action_new(ACTION_TRANSPORT_DISEMBARK3,
672 ACTRES_TRANSPORT_DISEMBARK,
673 FALSE, TRUE,
674 MAK_REGULAR, 1, 1, FALSE);
675 actions[ACTION_TRANSPORT_DISEMBARK4] =
676 unit_action_new(ACTION_TRANSPORT_DISEMBARK4,
677 ACTRES_TRANSPORT_DISEMBARK,
678 FALSE, TRUE,
679 MAK_REGULAR, 1, 1, FALSE);
680 actions[ACTION_TRANSPORT_EMBARK] =
681 unit_action_new(ACTION_TRANSPORT_EMBARK, ACTRES_TRANSPORT_EMBARK,
682 TRUE, TRUE,
683 MAK_REGULAR, 1, 1, FALSE);
684 actions[ACTION_TRANSPORT_EMBARK2] =
685 unit_action_new(ACTION_TRANSPORT_EMBARK2, ACTRES_TRANSPORT_EMBARK,
686 TRUE, TRUE,
687 MAK_REGULAR, 1, 1, FALSE);
688 actions[ACTION_TRANSPORT_EMBARK3] =
689 unit_action_new(ACTION_TRANSPORT_EMBARK3, ACTRES_TRANSPORT_EMBARK,
690 TRUE, TRUE,
691 MAK_REGULAR, 1, 1, FALSE);
692 actions[ACTION_TRANSPORT_EMBARK4] =
693 unit_action_new(ACTION_TRANSPORT_EMBARK4, ACTRES_TRANSPORT_EMBARK,
694 TRUE, TRUE,
695 MAK_REGULAR, 1, 1, FALSE);
696 actions[ACTION_SPY_ATTACK] =
697 unit_action_new(ACTION_SPY_ATTACK, ACTRES_SPY_ATTACK,
698 FALSE, TRUE,
699 MAK_STAYS, 1, 1, FALSE);
700 actions[ACTION_HUT_ENTER] =
701 unit_action_new(ACTION_HUT_ENTER, ACTRES_HUT_ENTER,
702 FALSE, TRUE,
703 MAK_REGULAR, 1, 1, FALSE);
704 actions[ACTION_HUT_ENTER2] =
705 unit_action_new(ACTION_HUT_ENTER2, ACTRES_HUT_ENTER,
706 FALSE, TRUE,
707 MAK_REGULAR, 1, 1, FALSE);
708 actions[ACTION_HUT_ENTER3] =
709 unit_action_new(ACTION_HUT_ENTER3, ACTRES_HUT_ENTER,
710 FALSE, TRUE,
711 MAK_REGULAR, 1, 1, FALSE);
712 actions[ACTION_HUT_ENTER4] =
713 unit_action_new(ACTION_HUT_ENTER4, ACTRES_HUT_ENTER,
714 FALSE, TRUE,
715 MAK_REGULAR, 1, 1, FALSE);
716 actions[ACTION_HUT_FRIGHTEN] =
717 unit_action_new(ACTION_HUT_FRIGHTEN, ACTRES_HUT_FRIGHTEN,
718 FALSE, TRUE,
719 MAK_REGULAR, 1, 1, FALSE);
720 actions[ACTION_HUT_FRIGHTEN2] =
721 unit_action_new(ACTION_HUT_FRIGHTEN2, ACTRES_HUT_FRIGHTEN,
722 FALSE, TRUE,
723 MAK_REGULAR, 1, 1, FALSE);
724 actions[ACTION_HUT_FRIGHTEN3] =
725 unit_action_new(ACTION_HUT_FRIGHTEN3, ACTRES_HUT_FRIGHTEN,
726 FALSE, TRUE,
727 MAK_REGULAR, 1, 1, FALSE);
728 actions[ACTION_HUT_FRIGHTEN4] =
729 unit_action_new(ACTION_HUT_FRIGHTEN4, ACTRES_HUT_FRIGHTEN,
730 FALSE, TRUE,
731 MAK_REGULAR, 1, 1, FALSE);
732 actions[ACTION_UNIT_MOVE] =
733 unit_action_new(ACTION_UNIT_MOVE, ACTRES_UNIT_MOVE,
734 TRUE, TRUE,
735 MAK_REGULAR, 1, 1, FALSE);
736 actions[ACTION_UNIT_MOVE2] =
737 unit_action_new(ACTION_UNIT_MOVE2, ACTRES_UNIT_MOVE,
738 TRUE, TRUE,
739 MAK_REGULAR, 1, 1, FALSE);
740 actions[ACTION_UNIT_MOVE3] =
741 unit_action_new(ACTION_UNIT_MOVE3, ACTRES_UNIT_MOVE,
742 TRUE, TRUE,
743 MAK_REGULAR, 1, 1, FALSE);
744 actions[ACTION_TELEPORT] =
745 unit_action_new(ACTION_TELEPORT, ACTRES_TELEPORT,
746 TRUE, TRUE,
747 MAK_TELEPORT, 1, 1, FALSE);
748 actions[ACTION_TELEPORT2] =
749 unit_action_new(ACTION_TELEPORT2, ACTRES_TELEPORT,
750 TRUE, TRUE,
751 MAK_TELEPORT, 1, 1, FALSE);
752 actions[ACTION_TELEPORT3] =
753 unit_action_new(ACTION_TELEPORT3, ACTRES_TELEPORT,
754 TRUE, TRUE,
755 MAK_TELEPORT, 1, 1, FALSE);
756 actions[ACTION_TELEPORT_CONQUER] =
757 unit_action_new(ACTION_TELEPORT_CONQUER, ACTRES_TELEPORT_CONQUER,
758 TRUE, TRUE,
759 MAK_TELEPORT, 1,
760 ACTION_DISTANCE_MAX, FALSE);
761 actions[ACTION_TELEPORT_FRIGHTEN] =
762 unit_action_new(ACTION_TELEPORT_FRIGHTEN,
763 ACTRES_TELEPORT,
764 TRUE, TRUE,
765 MAK_TELEPORT, 1,
766 ACTION_DISTANCE_MAX, FALSE);
767 actions[ACTION_TELEPORT_FRIGHTEN_CONQUER] =
768 unit_action_new(ACTION_TELEPORT_FRIGHTEN_CONQUER,
769 ACTRES_TELEPORT_CONQUER,
770 TRUE, TRUE,
771 MAK_TELEPORT, 1,
772 ACTION_DISTANCE_MAX, FALSE);
773 actions[ACTION_TELEPORT_ENTER] =
774 unit_action_new(ACTION_TELEPORT_ENTER,
775 ACTRES_TELEPORT,
776 TRUE, TRUE,
777 MAK_TELEPORT, 1,
778 ACTION_DISTANCE_MAX, FALSE);
779 actions[ACTION_TELEPORT_ENTER_CONQUER] =
780 unit_action_new(ACTION_TELEPORT_ENTER_CONQUER,
781 ACTRES_TELEPORT_CONQUER,
782 TRUE, TRUE,
783 MAK_TELEPORT, 1,
784 ACTION_DISTANCE_MAX, FALSE);
785 actions[ACTION_SCOUT] =
786 unit_action_new(ACTION_SCOUT, ACTRES_SCOUT,
787 TRUE, TRUE,
788 MAK_TELEPORT, 1,
789 ACTION_DISTANCE_MAX, FALSE);
790 actions[ACTION_GAIN_VETERANCY] =
791 unit_action_new(ACTION_GAIN_VETERANCY, ACTRES_ENABLER_CHECK,
792 TRUE, FALSE,
793 MAK_STAYS, 0, 0, FALSE);
794 actions[ACTION_ESCAPE] =
795 unit_action_new(ACTION_ESCAPE, ACTRES_ENABLER_CHECK,
796 TRUE, FALSE,
797 MAK_STAYS, 0, 0, FALSE);
798 actions[ACTION_USER_ACTION1] =
799 unit_action_new(ACTION_USER_ACTION1, ACTRES_NONE,
800 FALSE, TRUE,
801 MAK_UNREPRESENTABLE,
802 /* Overwritten by the ruleset */
803 0, 1, FALSE);
804 actions[ACTION_USER_ACTION2] =
805 unit_action_new(ACTION_USER_ACTION2, ACTRES_NONE,
806 FALSE, TRUE,
807 MAK_UNREPRESENTABLE,
808 /* Overwritten by the ruleset */
809 0, 1, FALSE);
810 actions[ACTION_USER_ACTION3] =
811 unit_action_new(ACTION_USER_ACTION3, ACTRES_NONE,
812 FALSE, TRUE,
813 MAK_UNREPRESENTABLE,
814 /* Overwritten by the ruleset */
815 0, 1, FALSE);
816 actions[ACTION_USER_ACTION4] =
817 unit_action_new(ACTION_USER_ACTION4, ACTRES_NONE,
818 FALSE, TRUE,
819 MAK_UNREPRESENTABLE,
820 /* Overwritten by the ruleset */
821 0, 1, FALSE);
822 actions[ACTION_COLLECT_RANSOM] =
823 unit_action_new(ACTION_COLLECT_RANSOM, ACTRES_COLLECT_RANSOM,
824 FALSE, TRUE,
825 /* Tries a forced move if the target unit's tile has
826 * no non-allied units and the occupychance dice roll
827 * tells it to move. */
828 MAK_FORCED,
829 1, 1, FALSE);
830
831 actions[ACTION_CIVIL_WAR] =
832 player_action_new(ACTION_CIVIL_WAR, ACTRES_ENABLER_CHECK);
833
834 actions[ACTION_FINISH_UNIT] =
835 city_action_new(ACTION_FINISH_UNIT, ACTRES_ENABLER_CHECK);
836
837 actions[ACTION_FINISH_BUILDING] =
838 city_action_new(ACTION_FINISH_BUILDING, ACTRES_ENABLER_CHECK);
839
840 /* The structure even for these need to be created, for
841 * the action_id_rule_name() to work on iterations. */
842
843 /*
844 actions[ACTION_UNUSED_1]
845 = unit_action_new(ACTION_UNUSED_1, ACTRES_NONE,
846 FALSE, FALSE,
847 MAK_UNREPRESENTABLE,
848 0, 0, FALSE);
849 */
850}
851
852/**********************************************************************/
855void actions_init(void)
856{
857 int i, j;
858
859 for (i = 0; i < ACTRES_LAST; i++) {
860 actlist_by_result[i] = action_list_new();
861 }
862 for (i = 0; i < ACTIVITY_LAST; i++) {
863 actlist_by_activity[i] = action_list_new();
864 }
865
866 /* Hard code the actions */
867 hard_code_actions();
868
869 /* Initialize the action enabler list */
870 action_iterate_all(act) {
871 action_enablers_by_action[act] = action_enabler_list_new();
872 } action_iterate_all_end;
873
874 /* Initialize action obligatory hard requirements. */
875 oblig_hard_reqs_init();
876
877 /* Obligatory hard requirements are sorted by requirement in the source
878 * code. This makes it easy to read, modify and explain it. */
879 hard_code_oblig_hard_reqs();
880
881 /* Initialize the action auto performers. */
882 for (i = 0; i < MAX_NUM_ACTION_AUTO_PERFORMERS; i++) {
883 /* Nothing here. Nothing after this point. */
884 auto_perfs[i].cause = AAPC_COUNT;
885
886 /* The criteria to pick *this* auto performer for its cause. */
887 requirement_vector_init(&auto_perfs[i].reqs);
888
889 for (j = 0; j < MAX_NUM_ACTIONS; j++) {
890 /* Nothing here. Nothing after this point. */
891 auto_perfs[i].alternatives[j] = ACTION_NONE;
892 }
893 }
894
895 /* The actions them self are now initialized. */
896 actions_initialized = TRUE;
897}
898
899/**********************************************************************/
904void actions_rs_pre_san_gen(void)
905{
906 /* Some obligatory hard requirements needs access to the rest of the
907 * ruleset. */
908 hard_code_oblig_hard_reqs_ruleset();
909}
910
911/**********************************************************************/
914void actions_free(void)
915{
916 int i;
917
918 /* Don't consider the actions to be initialized any longer. */
919 actions_initialized = FALSE;
920
921 action_iterate_all(act) {
922 action_enabler_list_iterate(action_enablers_by_action[act], enabler) {
923 action_enabler_free(enabler);
924 } action_enabler_list_iterate_end;
925
926 action_enabler_list_destroy(action_enablers_by_action[act]);
927
928 FC_FREE(actions[act]);
929 } action_iterate_all_end;
930
931 /* Free the obligatory hard action requirements. */
932 oblig_hard_reqs_free();
933
934 /* Free the action auto performers. */
935 for (i = 0; i < MAX_NUM_ACTION_AUTO_PERFORMERS; i++) {
936 requirement_vector_free(&auto_perfs[i].reqs);
937 }
938
939 astr_free(&ui_name_str);
940
941 for (i = 0; i < ACTRES_LAST; i++) {
942 action_list_destroy(actlist_by_result[i]);
943 actlist_by_result[i] = nullptr;
944 }
945 for (i = 0; i < ACTIVITY_LAST; i++) {
946 action_list_destroy(actlist_by_activity[i]);
947 actlist_by_activity[i] = nullptr;
948 }
949}
950
951/**********************************************************************/
956bool actions_are_ready(void)
957{
958 if (!actions_initialized) {
959 /* The actions them self aren't initialized yet. */
960 return FALSE;
961 }
962
963 action_noninternal_iterate(act) {
964 if (actions[act]->ui_name[0] == '\0') {
965 /* A noninternal action without a UI name exists means that
966 * the ruleset haven't loaded yet. The ruleset loading will assign
967 * a default name to any actions not named by the ruleset.
968 * The client will get this name from the server. */
969 return FALSE;
970 }
971 } action_noninternal_iterate_end;
972
973 /* The actions should be ready for use. */
974 return TRUE;
975}
976
977/**********************************************************************/
980static struct action *action_new(action_id id,
981 enum action_actor_kind aak,
982 enum action_result result,
983 const int min_distance,
984 const int max_distance,
985 bool actor_consuming_always)
986{
987 struct action *action;
988
989 action = fc_malloc(sizeof(*action));
990
991 action->id = id;
992 action->configured = FALSE;
993
994 action->result = result;
995
996 if (result != ACTRES_LAST) {
997 enum unit_activity act = actres_activity_result(result);
998
999 action_list_append(actlist_by_result[result], action);
1000
1001 if (act != ACTIVITY_LAST) {
1002 action_list_append(actlist_by_activity[act], action);
1003 }
1004 }
1005
1006 /* Not set here */
1007 BV_CLR_ALL(action->sub_results);
1008
1009 action->actor_kind = aak;
1010 action->target_kind = actres_target_kind_default(result);
1011 action->sub_target_kind = actres_sub_target_kind_default(result);
1012 action->target_complexity = actres_target_compl_calc(result);
1013
1014 /* ASTK_NONE implies ACT_TGT_COMPL_SIMPLE and
1015 * !ASTK_NONE implies !ACT_TGT_COMPL_SIMPLE */
1016 fc_assert_msg(((action->sub_target_kind == ASTK_NONE
1017 && action->target_complexity == ACT_TGT_COMPL_SIMPLE)
1018 || (action->sub_target_kind != ASTK_NONE
1019 && action->target_complexity != ACT_TGT_COMPL_SIMPLE)),
1020 "%s contradicts itself regarding sub targets.",
1021 action_rule_name(action));
1022
1023 /* The distance between the actor and itself is always 0. */
1024 fc_assert(action->target_kind != ATK_SELF
1025 || (min_distance == 0 && max_distance == 0));
1026
1027 action->min_distance = min_distance;
1028 action->max_distance = max_distance;
1029
1030 action->actor_consuming_always = actor_consuming_always;
1031
1032 /* Loaded from the ruleset. Until generalized actions are ready it has to
1033 * be defined separately from other action data. */
1034 action->ui_name[0] = '\0';
1035 action->quiet = FALSE;
1036 BV_CLR_ALL(action->blocked_by);
1037
1038 return action;
1039}
1040
1041/**********************************************************************/
1044static struct action *
1045unit_action_new(action_id id,
1046 enum action_result result,
1047 bool rare_pop_up,
1048 bool unitwaittime_controlled,
1049 enum moves_actor_kind moves_actor,
1050 const int min_distance,
1051 const int max_distance,
1052 bool actor_consuming_always)
1053{
1054 struct action *act = action_new(id, AAK_UNIT, result,
1055 min_distance, max_distance,
1056 actor_consuming_always);
1057
1058 act->actor.is_unit.rare_pop_up = rare_pop_up;
1059
1060 act->actor.is_unit.unitwaittime_controlled = unitwaittime_controlled;
1061
1062 act->actor.is_unit.moves_actor = moves_actor;
1063
1064 return act;
1065}
1066
1067/**********************************************************************/
1070static struct action *player_action_new(action_id id,
1071 enum action_result result)
1072{
1073 struct action *act = action_new(id, AAK_PLAYER, result,
1074 0, 0, FALSE);
1075
1076 return act;
1077}
1078
1079/**********************************************************************/
1082static struct action *city_action_new(action_id id,
1083 enum action_result result)
1084{
1085 struct action *act = action_new(id, AAK_CITY, result,
1086 0, 0, FALSE);
1087
1088 return act;
1089}
1090
1091/**********************************************************************/
1094bool action_id_exists(const action_id act_id)
1095{
1096 /* Actions are still hard coded. */
1097 return gen_action_is_valid(act_id) && actions[act_id];
1098}
1099
1100/**********************************************************************/
1105struct action *action_by_rule_name(const char *name)
1106{
1107 /* Actions are still hard coded in the gen_action enum. */
1108 action_id act_id = gen_action_by_name(name, fc_strcasecmp);
1109
1110 if (!action_id_exists(act_id)) {
1111 /* Nothing to return. */
1112
1113 log_verbose("Asked for non existing action named %s", name);
1114
1115 return nullptr;
1116 }
1117
1118 return action_by_number(act_id);
1119}
1120
1121/**********************************************************************/
1124enum action_actor_kind action_get_actor_kind(const struct action *paction)
1125{
1126 fc_assert_ret_val_msg(paction, AAK_COUNT, "Action doesn't exist.");
1127
1128 return paction->actor_kind;
1129}
1130
1131/**********************************************************************/
1134enum action_target_kind action_get_target_kind(
1135 const struct action *paction)
1136{
1137 fc_assert_ret_val_msg(paction, ATK_COUNT, "Action doesn't exist.");
1138
1139 return paction->target_kind;
1140}
1141
1142/**********************************************************************/
1145enum action_sub_target_kind action_get_sub_target_kind(
1146 const struct action *paction)
1147{
1148 fc_assert_ret_val_msg(paction, ASTK_COUNT, "Action doesn't exist.");
1149
1150 return paction->sub_target_kind;
1151}
1152
1153/**********************************************************************/
1158bool action_has_complex_target(const struct action *paction)
1159{
1160 fc_assert_ret_val(paction != nullptr, FALSE);
1161
1162 return paction->target_complexity >= ACT_TGT_COMPL_FLEXIBLE;
1163}
1164
1165/**********************************************************************/
1171bool action_requires_details(const struct action *paction)
1172{
1173 fc_assert_ret_val(paction != nullptr, FALSE);
1174
1175 return paction->target_complexity >= ACT_TGT_COMPL_MANDATORY;
1176}
1177
1178/**********************************************************************/
1186bool action_id_is_rare_pop_up(action_id act_id)
1187{
1188 fc_assert_ret_val_msg((action_id_exists(act_id)),
1189 FALSE, "Action %d don't exist.", act_id);
1190 fc_assert_ret_val(action_id_get_actor_kind(act_id) == AAK_UNIT, FALSE);
1191
1192 return actions[act_id]->actor.is_unit.rare_pop_up;
1193}
1194
1195/**********************************************************************/
1199bool action_distance_inside_max(const struct action *action,
1200 const int distance)
1201{
1202 return (distance <= action->max_distance
1203 || action->max_distance == ACTION_DISTANCE_UNLIMITED);
1204}
1205
1206/**********************************************************************/
1210bool action_distance_accepted(const struct action *action,
1211 const int distance)
1212{
1213 fc_assert_ret_val(action, FALSE);
1214
1215 return (distance >= action->min_distance
1216 && action_distance_inside_max(action, distance));
1217}
1218
1219/**********************************************************************/
1222bool action_would_be_blocked_by(const struct action *blocked,
1223 const struct action *blocker)
1224{
1225 fc_assert_ret_val(blocked, FALSE);
1226 fc_assert_ret_val(blocker, FALSE);
1227
1228 return BV_ISSET(blocked->blocked_by, action_number(blocker));
1229}
1230
1231/**********************************************************************/
1234int action_number(const struct action *action)
1235{
1236 return action->id;
1237}
1238
1239/**********************************************************************/
1242const char *action_rule_name(const struct action *action)
1243{
1244 /* Rule name is still hard coded. */
1245 return action_id_rule_name(action->id);
1246}
1247
1248/**********************************************************************/
1256const char *action_name_translation(const struct action *paction)
1257{
1258 /* Use action_id_name_translation() to format the UI name. */
1259 return action_id_name_translation(paction->id);
1260}
1261
1262/**********************************************************************/
1265const char *action_id_rule_name(action_id act_id)
1266{
1267 fc_assert_msg(actions[act_id], "Action %d don't exist.", act_id);
1268
1269 return gen_action_name(act_id);
1270}
1271
1272/**********************************************************************/
1276const char *action_id_name_translation(action_id act_id)
1277{
1278 return action_prepare_ui_name(act_id, "", ACTPROB_NA, nullptr);
1279}
1280
1281/**********************************************************************/
1284const char *action_get_ui_name_mnemonic(action_id act_id,
1285 const char *mnemonic)
1286{
1287 return action_prepare_ui_name(act_id, mnemonic, ACTPROB_NA, nullptr);
1288}
1289
1290/**********************************************************************/
1297static const char *action_prob_to_text(const struct act_prob prob)
1298{
1299 static struct astring chance = ASTRING_INIT;
1300
1301 /* How to interpret action probabilities like prob is documented in
1302 * fc_types.h */
1303 if (action_prob_is_signal(prob)) {
1304 fc_assert(action_prob_not_impl(prob)
1305 || action_prob_not_relevant(prob));
1306
1307 /* Unknown because of missing server support or should not exits. */
1308 return nullptr;
1309 }
1310
1311 if (prob.min == prob.max) {
1312 /* Only one probability in range. */
1313
1314 /* TRANS: the probability that an action will succeed. Given in
1315 * percentage. Resolution is 0.5%. */
1316 astr_set(&chance, _("%.1f%%"), (double)prob.max / ACTPROB_VAL_1_PCT);
1317 } else {
1318 /* TRANS: the interval (end points included) where the probability of
1319 * the action's success is. Given in percentage. Resolution is 0.5%. */
1320 astr_set(&chance, _("[%.1f%%, %.1f%%]"),
1321 (double)prob.min / ACTPROB_VAL_1_PCT,
1322 (double)prob.max / ACTPROB_VAL_1_PCT);
1323 }
1324
1325 return astr_str(&chance);
1326}
1327
1328/**********************************************************************/
1338const char *action_prepare_ui_name(action_id act_id, const char *mnemonic,
1339 const struct act_prob prob,
1340 const char *custom)
1341{
1342 struct astring chance = ASTRING_INIT;
1343
1344 /* Text representation of the probability. */
1345 const char *probtxt;
1346
1347 if (!actions_are_ready()) {
1348 /* Could be a client who haven't gotten the ruleset yet */
1349
1350 /* so there shouldn't be any action probability to show */
1351 fc_assert(action_prob_not_relevant(prob));
1352
1353 /* but the action should be valid */
1354 fc_assert_ret_val_msg(action_id_exists(act_id),
1355 "Invalid action",
1356 "Invalid action %d", act_id);
1357
1358 /* and no custom text will be inserted */
1359 fc_assert(custom == nullptr || custom[0] == '\0');
1360
1361 /* Make the best of what is known */
1362 astr_set(&ui_name_str, _("%s%s (name may be wrong)"),
1363 mnemonic, action_id_rule_name(act_id));
1364
1365 /* Return the guess. */
1366 return astr_str(&ui_name_str);
1367 }
1368
1369 probtxt = action_prob_to_text(prob);
1370
1371 /* Format the info part of the action's UI name. */
1372 if (probtxt != nullptr && custom != nullptr) {
1373 /* TRANS: action UI name's info part with custom info and probability.
1374 * Hint: you can move the paren handling from this string to the action
1375 * names if you need to add extra information (like a mnemonic letter
1376 * that doesn't appear in the action UI name) to it. In that case you
1377 * must do so for all strings with this comment and for every action
1378 * name. To avoid a `()` when no UI name info part is added you have
1379 * to add the extra information to every action name or remove the
1380 * surrounding parens. */
1381 astr_set(&chance, _(" (%s; %s)"), custom, probtxt);
1382 } else if (probtxt != nullptr) {
1383 /* TRANS: action UI name's info part with probability.
1384 * Hint: you can move the paren handling from this string to the action
1385 * names if you need to add extra information (like a mnemonic letter
1386 * that doesn't appear in the action UI name) to it. In that case you
1387 * must do so for all strings with this comment and for every action
1388 * name. To avoid a `()` when no UI name info part is added you have
1389 * to add the extra information to every action name or remove the
1390 * surrounding parens. */
1391 astr_set(&chance, _(" (%s)"), probtxt);
1392 } else if (custom != nullptr) {
1393 /* TRANS: action UI name's info part with custom info.
1394 * Hint: you can move the paren handling from this string to the action
1395 * names if you need to add extra information (like a mnemonic letter
1396 * that doesn't appear in the action UI name) to it. In that case you
1397 * must do so for all strings with this comment and for every action
1398 * name. To avoid a `()` when no UI name info part is added you have
1399 * to add the extra information to every action name or remove the
1400 * surrounding parens. */
1401 astr_set(&chance, _(" (%s)"), custom);
1402 } else {
1403 /* No info part to display. */
1404 astr_clear(&chance);
1405 }
1406
1407 fc_assert_msg(actions[act_id], "Action %d don't exist.", act_id);
1408
1409 /* Escape any instances of the mnemonic in the action's UI format string.
1410 * (Assumes any mnemonic can be escaped by doubling, and that they are
1411 * unlikely to appear in a format specifier. True for clients seen so
1412 * far: Gtk's _ and Qt's &) */
1413 {
1414 struct astring fmtstr = ASTRING_INIT;
1415 const char *ui_name = _(actions[act_id]->ui_name);
1416
1417 if (mnemonic[0] != '\0') {
1418 const char *hit;
1419
1420 fc_assert(!strchr(mnemonic, '%'));
1421 while ((hit = strstr(ui_name, mnemonic))) {
1422 astr_add(&fmtstr, "%.*s%s%s", (int)(hit - ui_name), ui_name,
1423 mnemonic, mnemonic);
1424 ui_name = hit + strlen(mnemonic);
1425 }
1426 }
1427 astr_add(&fmtstr, "%s", ui_name);
1428
1429 /* Use the modified format string */
1430 astr_set(&ui_name_str, astr_str(&fmtstr), mnemonic,
1431 astr_str(&chance));
1432
1433 astr_free(&fmtstr);
1434 }
1435
1436 astr_free(&chance);
1437
1438 return astr_str(&ui_name_str);
1439}
1440
1441/**********************************************************************/
1449const char *action_prob_explain(const struct act_prob prob)
1450{
1451 static struct astring tool_tip = ASTRING_INIT;
1452
1453 if (action_prob_is_signal(prob)) {
1454 fc_assert(action_prob_not_impl(prob));
1455
1456 /* Missing server support. No in game action will change this. */
1457 astr_clear(&tool_tip);
1458 } else if (prob.min == prob.max) {
1459 /* TRANS: action probability of success. Given in percentage.
1460 * Resolution is 0.5%. */
1461 astr_set(&tool_tip, _("The probability of success is %.1f%%."),
1462 (double)prob.max / ACTPROB_VAL_1_PCT);
1463 } else {
1464 astr_set(&tool_tip,
1465 /* TRANS: action probability interval (min to max). Given in
1466 * percentage. Resolution is 0.5%. The string at the end is
1467 * shown when the interval is wide enough to not be caused by
1468 * rounding. It explains that the interval is imprecise because
1469 * the player doesn't have enough information. */
1470 _("The probability of success is %.1f%%, %.1f%% or somewhere"
1471 " in between.%s"),
1472 (double)prob.min / ACTPROB_VAL_1_PCT,
1473 (double)prob.max / ACTPROB_VAL_1_PCT,
1474 prob.max - prob.min > 1 ?
1475 /* TRANS: explanation used in the action probability tooltip
1476 * above. Preserve leading space. */
1477 _(" (This is the most precise interval I can calculate "
1478 "given the information our nation has access to.)") :
1479 "");
1480 }
1481
1482 return astr_str(&tool_tip);
1483}
1484
1485/**********************************************************************/
1489int action_get_role(const struct action *paction)
1490{
1491 fc_assert_msg(AAK_UNIT == action_get_actor_kind(paction),
1492 "Action %s isn't performed by a unit",
1493 action_rule_name(paction));
1494
1495 return paction->id + L_LAST;
1496}
1497
1498/**********************************************************************/
1501struct action_enabler *action_enabler_new(void)
1502{
1503 struct action_enabler *enabler;
1504
1505 enabler = fc_malloc(sizeof(*enabler));
1506 enabler->rulesave.ruledit_disabled = FALSE;
1507 enabler->rulesave.comment = nullptr;
1508 requirement_vector_init(&enabler->actor_reqs);
1509 requirement_vector_init(&enabler->target_reqs);
1510
1511 /* Make sure that action doesn't end up as a random value that happens to
1512 * be a valid action id. */
1513 enabler->action = ACTION_NONE;
1514
1515 return enabler;
1516}
1517
1518/**********************************************************************/
1521void action_enabler_free(struct action_enabler *enabler)
1522{
1523 if (enabler->rulesave.comment != nullptr) {
1524 free(enabler->rulesave.comment);
1525 }
1526
1527 requirement_vector_free(&enabler->actor_reqs);
1528 requirement_vector_free(&enabler->target_reqs);
1529
1530 free(enabler);
1531}
1532
1533/**********************************************************************/
1536struct action_enabler *
1537action_enabler_copy(const struct action_enabler *original)
1538{
1539 struct action_enabler *enabler = action_enabler_new();
1540
1541 enabler->action = original->action;
1542
1543 requirement_vector_copy(&enabler->actor_reqs, &original->actor_reqs);
1544 requirement_vector_copy(&enabler->target_reqs, &original->target_reqs);
1545
1546 return enabler;
1547}
1548
1549/**********************************************************************/
1552void action_enabler_add(struct action_enabler *enabler)
1553{
1554 /* Sanity check: a non existing action enabler can't be added. */
1555 fc_assert_ret(enabler);
1556 /* Sanity check: a non existing action doesn't have enablers. */
1557 fc_assert_ret(action_id_exists(enabler_get_action_id(enabler)));
1558
1559 action_enabler_list_append(
1560 action_enablers_for_action(enabler_get_action_id(enabler)),
1561 enabler);
1562}
1563
1564/**********************************************************************/
1569bool action_enabler_remove(struct action_enabler *enabler)
1570{
1571 /* Sanity check: a non existing action enabler can't be removed. */
1572 fc_assert_ret_val(enabler, FALSE);
1573 /* Sanity check: a non existing action doesn't have enablers. */
1574 fc_assert_ret_val(action_id_exists(enabler_get_action_id(enabler)), FALSE);
1575
1576 return action_enabler_list_remove(
1577 action_enablers_for_action(enabler_get_action_id(enabler)),
1578 enabler);
1579}
1580
1581/**********************************************************************/
1584struct action_enabler_list *
1585action_enablers_for_action(action_id action)
1586{
1587 /* Sanity check: a non existing action doesn't have enablers. */
1588 fc_assert_ret_val(action_id_exists(action), nullptr);
1589
1590 return action_enablers_by_action[action];
1591}
1592
1593/**********************************************************************/
1604static struct req_vec_problem *
1605ae_suggest_repair_if_no_oblig(const struct action_enabler *enabler,
1606 const struct obligatory_req_vector *oblig)
1607{
1608 struct action *paction;
1609
1610 /* Sanity check: a non existing action enabler is missing but it doesn't
1611 * miss any obligatory hard requirements. */
1612 fc_assert_ret_val(enabler, nullptr);
1613
1614 /* Sanity check: a non existing action doesn't have any obligatory hard
1615 * requirements. */
1616 fc_assert_ret_val(action_id_exists(enabler_get_action_id(enabler)), nullptr);
1617 paction = enabler_get_action(enabler);
1618
1619 /* No obligatory hard requirements. */
1620 fc_assert_ret_val(oblig, nullptr);
1621
1622 obligatory_req_vector_iterate(oblig, obreq) {
1623 struct req_vec_problem *out;
1624 int i;
1625 bool fulfilled = FALSE;
1626
1627 /* Check each alternative. */
1628 for (i = 0; i < obreq->contras->alternatives; i++) {
1629 const struct requirement_vector *ae_vec;
1630
1631 /* Select action enabler requirement vector. */
1632 ae_vec = (obreq->contras->alternative[i].is_target
1633 ? &enabler->target_reqs
1634 : &enabler->actor_reqs);
1635
1636 if (does_req_contradicts_reqs(&obreq->contras->alternative[i].req,
1637 ae_vec)
1638 /* Consider the hard requirement fulfilled since a universal that
1639 * never is there always will be absent in this ruleset. */
1640 || (obreq->contras->alternative[i].req.present
1641 && universal_never_there(
1642 &obreq->contras->alternative[i].req.source))) {
1643 /* It is enough that one alternative accepts the enabler. */
1644 fulfilled = TRUE;
1645 break;
1646 }
1647
1648 /* Fall back to the next alternative */
1649 }
1650
1651 if (fulfilled) {
1652 /* This obligatory hard requirement isn't a problem. */
1653 continue;
1654 }
1655
1656 /* Missing hard obligatory requirement detected */
1657
1658 out = req_vec_problem_new(obreq->contras->alternatives,
1659 obreq->error_msg,
1660 action_rule_name(paction));
1661
1662 for (i = 0; i < obreq->contras->alternatives; i++) {
1663 const struct requirement_vector *ae_vec;
1664
1665 /* Select action enabler requirement vector. */
1666 ae_vec = (obreq->contras->alternative[i].is_target
1667 ? &enabler->target_reqs
1668 : &enabler->actor_reqs);
1669
1670 /* The suggested fix is to append a requirement that makes the enabler
1671 * contradict the missing hard obligatory requirement detector. */
1672 out->suggested_solutions[i].operation = RVCO_APPEND;
1673 out->suggested_solutions[i].vector_number
1674 = action_enabler_vector_number(enabler, ae_vec);
1675
1676 /* Change the requirement from what should conflict to what is
1677 * wanted. */
1678 out->suggested_solutions[i].req.present
1679 = !obreq->contras->alternative[i].req.present;
1680 out->suggested_solutions[i].req.source
1681 = obreq->contras->alternative[i].req.source;
1682 out->suggested_solutions[i].req.range
1683 = obreq->contras->alternative[i].req.range;
1684 out->suggested_solutions[i].req.survives
1685 = obreq->contras->alternative[i].req.survives;
1686 out->suggested_solutions[i].req.quiet
1687 = obreq->contras->alternative[i].req.quiet;
1688 }
1689
1690 /* Return the first problem found. The next problem will be detected
1691 * during the next call. */
1692 return out;
1693 } obligatory_req_vector_iterate_end;
1694
1695 /* No obligatory req problems found. */
1696 return nullptr;
1697}
1698
1699/**********************************************************************/
1708struct req_vec_problem *
1709action_enabler_suggest_repair_oblig(const struct action_enabler *enabler)
1710{
1711 struct action *paction;
1712 enum action_sub_result sub_res;
1713 struct req_vec_problem *out;
1714
1715 /* Sanity check: a non existing action enabler is missing but it doesn't
1716 * miss any obligatory hard requirements. */
1717 fc_assert_ret_val(enabler, nullptr);
1718
1719 /* Sanity check: a non existing action doesn't have any obligatory hard
1720 * requirements. */
1721 fc_assert_ret_val(action_id_exists(enabler_get_action_id(enabler)), nullptr);
1722 paction = enabler_get_action(enabler);
1723
1724 if (paction->result != ACTRES_NONE) {
1725 /* A hard coded action result may mean obligatory requirements. */
1726 out = ae_suggest_repair_if_no_oblig(enabler, oblig_hard_reqs_get(paction->result));
1727 if (out != nullptr) {
1728 return out;
1729 }
1730 }
1731
1732 for (sub_res = action_sub_result_begin();
1733 sub_res != action_sub_result_end();
1734 sub_res = action_sub_result_next(sub_res)) {
1735 if (!BV_ISSET(paction->sub_results, sub_res)) {
1736 /* Not relevant */
1737 continue;
1738 }
1739
1740 /* The action has this sub result. Check its hard requirements. */
1741 out = ae_suggest_repair_if_no_oblig(enabler,
1742 oblig_hard_reqs_get_sub(sub_res));
1743 if (out != nullptr) {
1744 return out;
1745 }
1746 }
1747
1748 /* No obligatory req problems found. */
1749 return nullptr;
1750}
1751
1752/**********************************************************************/
1758static struct requirement *
1759req_vec_first_local_diplrel(const struct requirement_vector *vec)
1760{
1761 requirement_vector_iterate(vec, preq) {
1762 if (preq->source.kind == VUT_DIPLREL
1763 && preq->range == REQ_RANGE_LOCAL) {
1764 return preq;
1765 }
1766 } requirement_vector_iterate_end;
1767
1768 return nullptr;
1769}
1770
1771/**********************************************************************/
1777static struct req_vec_problem *
1778enabler_tile_tgt_local_diplrel_implies_claimed(
1779 const struct action_enabler *enabler)
1780{
1781 struct req_vec_problem *out;
1782 struct requirement *local_diplrel;
1783 struct requirement *claimed_req;
1784 struct requirement tile_is_claimed;
1785 struct requirement tile_is_unclaimed;
1786 struct action *paction = enabler_get_action(enabler);
1787 struct astring astr;
1788
1789 if (action_get_target_kind(paction) != ATK_TILE) {
1790 /* Not tile targeted */
1791 return nullptr;
1792 }
1793
1794 local_diplrel = req_vec_first_local_diplrel(&enabler->actor_reqs);
1795 if (local_diplrel == nullptr) {
1796 /* No local diplrel */
1797 return nullptr;
1798 }
1799
1800 /* Tile is unclaimed as a requirement. */
1801 tile_is_unclaimed.range = REQ_RANGE_TILE;
1802 tile_is_unclaimed.survives = FALSE;
1803 tile_is_unclaimed.source.kind = VUT_CITYTILE;
1804 tile_is_unclaimed.present = FALSE;
1805 tile_is_unclaimed.source.value.citytile = CITYT_CLAIMED;
1806
1807 claimed_req = req_vec_first_contradiction_in_vec(&tile_is_unclaimed,
1808 &enabler->target_reqs);
1809
1810 if (claimed_req) {
1811 /* Already clear */
1812 return nullptr;
1813 }
1814
1815 /* Tile is claimed as a requirement. */
1816 tile_is_claimed.range = REQ_RANGE_TILE;
1817 tile_is_claimed.survives = FALSE;
1818 tile_is_claimed.source.kind = VUT_CITYTILE;
1819 tile_is_claimed.present = TRUE;
1820 tile_is_claimed.source.value.citytile = CITYT_CLAIMED;
1821
1822 out = req_vec_problem_new(
1823 1,
1824 /* TRANS: ruledit shows this when an enabler for a tile targeted
1825 * action requires that the actor has a diplomatic relationship to
1826 * the target but doesn't require that the target tile is claimed.
1827 * (DiplRel requirements to an unclaimed tile are never fulfilled
1828 * so this is implicit.) */
1829 N_("Requirement {%s} of action \"%s\" implies a claimed "
1830 "tile. No diplomatic relation to Nature."),
1831 req_to_fstring(local_diplrel, &astr), action_rule_name(paction));
1832
1833 astr_free(&astr);
1834
1835 /* The solution is to add the requirement that the tile is claimed */
1836 out->suggested_solutions[0].req = tile_is_claimed;
1837 out->suggested_solutions[0].vector_number
1838 = action_enabler_vector_number(enabler, &enabler->target_reqs);
1839 out->suggested_solutions[0].operation = RVCO_APPEND;
1840
1841 return out;
1842}
1843
1844/**********************************************************************/
1850static struct req_vec_problem *
1851enabler_first_self_contradiction(const struct action_enabler *enabler)
1852{
1853 struct req_vec_problem *out;
1854 struct requirement *local_diplrel;
1855 struct requirement *unclaimed_req;
1856 struct requirement tile_is_claimed;
1857 struct action *paction = enabler_get_action(enabler);
1858 struct astring astr1;
1859 struct astring astr2;
1860
1861 if (action_get_target_kind(paction) != ATK_TILE) {
1862 /* Not tile targeted */
1863 return nullptr;
1864 }
1865
1866 local_diplrel = req_vec_first_local_diplrel(&enabler->actor_reqs);
1867 if (local_diplrel == nullptr) {
1868 /* No local diplrel */
1869 return nullptr;
1870 }
1871
1872 /* Tile is claimed as a requirement. */
1873 tile_is_claimed.range = REQ_RANGE_TILE;
1874 tile_is_claimed.survives = FALSE;
1875 tile_is_claimed.source.kind = VUT_CITYTILE;
1876 tile_is_claimed.present = TRUE;
1877 tile_is_claimed.source.value.citytile = CITYT_CLAIMED;
1878
1879 unclaimed_req = req_vec_first_contradiction_in_vec(&tile_is_claimed,
1880 &enabler->target_reqs);
1881
1882 if (unclaimed_req == nullptr) {
1883 /* No unclaimed req */
1884 return nullptr;
1885 }
1886
1887 out = req_vec_problem_new(
1888 2,
1889 /* TRANS: ruledit shows this when an enabler for a tile targeted
1890 * action requires that the target tile is unclaimed and that the
1891 * actor has a diplomatic relationship to the target. (DiplRel
1892 * requirements to an unclaimed tile are never fulfilled.) */
1893 N_("In enabler for \"%s\": No diplomatic relation to Nature."
1894 " Requirements {%s} and {%s} contradict each other."),
1895 action_rule_name(paction),
1896 req_to_fstring(local_diplrel, &astr1),
1897 req_to_fstring(unclaimed_req, &astr2));
1898
1899 astr_free(&astr1);
1900 astr_free(&astr2);
1901
1902 /* The first suggestion is to remove the diplrel */
1903 out->suggested_solutions[0].req = *local_diplrel;
1904 out->suggested_solutions[0].vector_number
1905 = action_enabler_vector_number(enabler, &enabler->actor_reqs);
1906 out->suggested_solutions[0].operation = RVCO_REMOVE;
1907
1908 /* The 2nd is to remove the requirement that the tile is unclaimed */
1909 out->suggested_solutions[1].req = *unclaimed_req;
1910 out->suggested_solutions[1].vector_number
1911 = action_enabler_vector_number(enabler, &enabler->target_reqs);
1912 out->suggested_solutions[1].operation = RVCO_REMOVE;
1913
1914 return out;
1915}
1916
1917/**********************************************************************/
1922struct req_vec_problem *
1923action_enabler_suggest_repair(const struct action_enabler *enabler)
1924{
1925 struct req_vec_problem *out;
1926
1927 out = action_enabler_suggest_repair_oblig(enabler);
1928 if (out != nullptr) {
1929 return out;
1930 }
1931
1932 /* Look for errors in the requirement vectors. */
1933 out = req_vec_suggest_repair(&enabler->actor_reqs,
1934 action_enabler_vector_number,
1935 enabler);
1936 if (out != nullptr) {
1937 return out;
1938 }
1939
1940 out = req_vec_suggest_repair(&enabler->target_reqs,
1941 action_enabler_vector_number,
1942 enabler);
1943 if (out != nullptr) {
1944 return out;
1945 }
1946
1947 /* Enabler specific contradictions. */
1948 out = enabler_first_self_contradiction(enabler);
1949 if (out != nullptr) {
1950 return out;
1951 }
1952
1953 /* Needed in action not enabled explanation finding. */
1954 out = enabler_tile_tgt_local_diplrel_implies_claimed(enabler);
1955 if (out != nullptr) {
1956 return out;
1957 }
1958
1959 /* No problems found. */
1960 return nullptr;
1961}
1962
1963/**********************************************************************/
1970static struct req_vec_problem *
1971enabler_first_clarification(const struct action_enabler *enabler)
1972{
1973 struct req_vec_problem *out;
1974
1975 out = nullptr;
1976
1977 return out;
1978}
1979
1980/**********************************************************************/
1988struct req_vec_problem *
1989action_enabler_suggest_improvement(const struct action_enabler *enabler)
1990{
1991 struct action *paction;
1992 struct req_vec_problem *out;
1993
1994 out = action_enabler_suggest_repair(enabler);
1995 if (out) {
1996 /* A bug, not just a potential improvement */
1997 return out;
1998 }
1999
2000 paction = enabler_get_action(enabler);
2001
2002 /* Look for improvement suggestions to the requirement vectors. */
2003 out = req_vec_suggest_improvement(&enabler->actor_reqs,
2004 action_enabler_vector_number,
2005 enabler);
2006 if (out) {
2007 return out;
2008 }
2009 out = req_vec_suggest_improvement(&enabler->target_reqs,
2010 action_enabler_vector_number,
2011 enabler);
2012 if (out) {
2013 return out;
2014 }
2015
2016 /* Detect unused action enablers. */
2017 if (action_get_actor_kind(paction) == AAK_UNIT) {
2018 bool has_user = FALSE;
2019
2020 unit_type_iterate(pactor) {
2021 if (action_actor_utype_hard_reqs_ok(paction, pactor)
2022 && requirement_fulfilled_by_unit_type(pactor,
2023 &(enabler->actor_reqs))) {
2024 has_user = TRUE;
2025 break;
2026 }
2027 } unit_type_iterate_end;
2028
2029 if (!has_user) {
2030 /* TRANS: ruledit warns a user about an unused action enabler */
2031 out = req_vec_problem_new(0, N_("Action enabler for \"%s\" is never"
2032 " used by any unit."),
2033 action_rule_name(paction));
2034 }
2035 }
2036 if (out != nullptr) {
2037 return out;
2038 }
2039
2040 out = enabler_first_clarification(enabler);
2041
2042 return out;
2043}
2044
2045/**********************************************************************/
2052req_vec_num_in_item
2053action_enabler_vector_number(const void *enabler,
2054 const struct requirement_vector *vec)
2055{
2056 struct action_enabler *ae = (struct action_enabler *)enabler;
2057
2058 if (vec == &ae->actor_reqs) {
2059 return 0;
2060 } else if (vec == &ae->target_reqs) {
2061 return 1;
2062 } else {
2063 return -1;
2064 }
2065}
2066
2067/********************************************************************/
2075struct requirement_vector *
2076action_enabler_vector_by_number(const void *enabler,
2077 req_vec_num_in_item number)
2078{
2079 struct action_enabler *ae = (struct action_enabler *)enabler;
2080
2081 fc_assert_ret_val(number >= 0, nullptr);
2082
2083 switch (number) {
2084 case 0:
2085 return &ae->actor_reqs;
2086 case 1:
2087 return &ae->target_reqs;
2088 default:
2089 return nullptr;
2090 }
2091}
2092
2093/*********************************************************************/
2100const char *action_enabler_vector_by_number_name(req_vec_num_in_item vec)
2101{
2102 switch (vec) {
2103 case 0:
2104 /* TRANS: requirement vector in an action enabler (ruledit) */
2105 return _("actor_reqs");
2106 case 1:
2107 /* TRANS: requirement vector in an action enabler (ruledit) */
2108 return _("target_reqs");
2109 default:
2110 return nullptr;
2111 }
2112}
2113
2114/**********************************************************************/
2119static const struct impr_type *
2120tgt_city_local_building(const struct city *target_city)
2121{
2122 /* Only used with city targets */
2123 fc_assert_ret_val(target_city, nullptr);
2124
2125 if (target_city->production.kind == VUT_IMPROVEMENT) {
2126 /* The local building is what the target city currently is building. */
2127 return target_city->production.value.building;
2128 } else {
2129 /* In the current semantic the local building is always the building
2130 * being built. */
2131 /* TODO: Consider making the local building the target building for
2132 * actions that allows specifying a building target. */
2133 return nullptr;
2134 }
2135}
2136
2137/**********************************************************************/
2142static const struct unit_type *
2143tgt_city_local_utype(const struct city *target_city)
2144{
2145 /* Only used with city targets */
2146 fc_assert_ret_val(target_city, nullptr);
2147
2148 if (target_city->production.kind == VUT_UTYPE) {
2149 /* The local unit type is what the target city currently is
2150 * building. */
2151 return target_city->production.value.utype;
2152 } else {
2153 /* In the current semantic the local utype is always the type of the
2154 * unit being built. */
2155 return nullptr;
2156 }
2157}
2158
2159/**********************************************************************/
2167static const struct tile *
2168blocked_find_target_tile(const struct action *act,
2169 const struct unit *actor_unit,
2170 const struct tile *target_tile_arg,
2171 const struct city *target_city,
2172 const struct unit *target_unit)
2173{
2174 if (target_tile_arg != nullptr) {
2175 /* Trust the caller. */
2176 return target_tile_arg;
2177 }
2178
2179 /* Action should always be set */
2180 fc_assert_ret_val(act, nullptr);
2181
2182 switch (action_get_target_kind(act)) {
2183 case ATK_CITY:
2184 fc_assert_ret_val(target_city, nullptr);
2185 return city_tile(target_city);
2186 case ATK_UNIT:
2187 if (target_unit == nullptr) {
2188 fc_assert(target_unit != nullptr);
2189 return nullptr;
2190 }
2191 return unit_tile(target_unit);
2192 case ATK_STACK:
2193 fc_assert_ret_val(target_unit || target_tile_arg, nullptr);
2194 if (target_unit) {
2195 return unit_tile(target_unit);
2196 }
2197
2198 fc__fallthrough;
2199 case ATK_TILE:
2200 case ATK_EXTRAS:
2201 fc_assert_ret_val(target_tile_arg, nullptr);
2202 return target_tile_arg;
2203 case ATK_SELF:
2204 if (actor_unit != nullptr) {
2205 return unit_tile(actor_unit);
2206 }
2207 return nullptr;
2208 case ATK_COUNT:
2209 /* Handled below. */
2210 break;
2211 }
2212
2213 fc_assert_msg(FALSE, "Bad action target kind %d for action %s",
2214 action_get_target_kind(act), action_rule_name(act));
2215 return nullptr;
2216}
2217
2218/**********************************************************************/
2227static const struct city *
2228blocked_find_target_city(const struct action *act,
2229 const struct unit *actor_unit,
2230 const struct tile *target_tile,
2231 const struct city *target_city_arg,
2232 const struct unit *target_unit)
2233{
2234 if (target_city_arg != nullptr) {
2235 /* Trust the caller. */
2236 return target_city_arg;
2237 }
2238
2239 /* action should always be set */
2240 fc_assert_ret_val(act, nullptr);
2241
2242 switch (action_get_target_kind(act)) {
2243 case ATK_CITY:
2244 fc_assert_ret_val(target_city_arg, nullptr);
2245 return target_city_arg;
2246 case ATK_UNIT:
2247 fc_assert_ret_val(target_unit, nullptr);
2248 fc_assert_ret_val(unit_tile(target_unit), nullptr);
2249 return tile_city(unit_tile(target_unit));
2250 case ATK_STACK:
2251 fc_assert_ret_val(target_unit || target_tile, nullptr);
2252 if (target_unit) {
2253 fc_assert_ret_val(unit_tile(target_unit), nullptr);
2254 return tile_city(unit_tile(target_unit));
2255 }
2256
2257 fc__fallthrough;
2258 case ATK_TILE:
2259 case ATK_EXTRAS:
2260 fc_assert_ret_val(target_tile, nullptr);
2261 return tile_city(target_tile);
2262 case ATK_SELF:
2263 if (actor_unit != nullptr) {
2264 struct tile *ptile = unit_tile(actor_unit);
2265
2266 if (ptile != nullptr) {
2267 return tile_city(ptile);
2268 }
2269 }
2270 return nullptr;
2271 case ATK_COUNT:
2272 /* Handled below. */
2273 break;
2274 }
2275
2276 fc_assert_msg(FALSE, "Bad action target kind %d for action %s",
2277 action_get_target_kind(act), action_rule_name(act));
2278 return nullptr;
2279}
2280
2281/**********************************************************************/
2287struct action *action_is_blocked_by(const struct civ_map *nmap,
2288 const struct action *act,
2289 const struct unit *actor_unit,
2290 const struct tile *target_tile_arg,
2291 const struct city *target_city_arg,
2292 const struct unit *target_unit)
2293{
2294 const struct tile *target_tile
2295 = blocked_find_target_tile(act, actor_unit, target_tile_arg,
2296 target_city_arg, target_unit);
2297 const struct city *target_city
2298 = blocked_find_target_city(act, actor_unit, target_tile,
2299 target_city_arg, target_unit);
2300
2301 action_iterate(blocker_id) {
2302 struct action *blocker = action_by_number(blocker_id);
2303
2304 if (action_get_actor_kind(blocker) != AAK_UNIT) {
2305 /* Currently, only unit's actions may block each other */
2306 continue;
2307 }
2308
2309 if (!action_would_be_blocked_by(act, blocker)) {
2310 /* It doesn't matter if it is legal. It won't block the action. */
2311 continue;
2312 }
2313
2314 switch (action_get_target_kind(blocker)) {
2315 case ATK_CITY:
2316 if (!target_city) {
2317 /* Can't be enabled. No target. */
2318 continue;
2319 }
2320 if (is_action_enabled_unit_on_city(nmap, blocker->id,
2321 actor_unit, target_city)) {
2322 return blocker;
2323 }
2324 break;
2325 case ATK_UNIT:
2326 if (!target_unit) {
2327 /* Can't be enabled. No target. */
2328 continue;
2329 }
2330 if (is_action_enabled_unit_on_unit(nmap, blocker->id,
2331 actor_unit, target_unit)) {
2332 return blocker;
2333 }
2334 break;
2335 case ATK_STACK:
2336 if (!target_tile) {
2337 /* Can't be enabled. No target. */
2338 continue;
2339 }
2340 if (is_action_enabled_unit_on_stack(nmap, blocker->id,
2341 actor_unit, target_tile)) {
2342 return blocker;
2343 }
2344 break;
2345 case ATK_TILE:
2346 if (!target_tile) {
2347 /* Can't be enabled. No target. */
2348 continue;
2349 }
2350 if (is_action_enabled_unit_on_tile(nmap, blocker->id,
2351 actor_unit, target_tile, nullptr)) {
2352 return blocker;
2353 }
2354 break;
2355 case ATK_EXTRAS:
2356 if (!target_tile) {
2357 /* Can't be enabled. No target. */
2358 continue;
2359 }
2360 if (is_action_enabled_unit_on_extras(nmap, blocker->id,
2361 actor_unit, target_tile, nullptr)) {
2362 return blocker;
2363 }
2364 break;
2365 case ATK_SELF:
2366 if (is_action_enabled_unit_on_self(nmap, blocker->id, actor_unit)) {
2367 return blocker;
2368 }
2369 break;
2370 case ATK_COUNT:
2371 fc_assert_action(action_id_get_target_kind(blocker->id) != ATK_COUNT,
2372 continue);
2373 break;
2374 }
2375 } action_iterate_end;
2376
2377 /* Not blocked. */
2378 return nullptr;
2379}
2380
2381/**********************************************************************/
2401static bool
2402action_actor_utype_hard_reqs_ok_full(const struct action *paction,
2403 const struct unit_type *actor_unittype,
2404 bool ignore_third_party)
2405{
2406 switch (paction->result) {
2407 case ACTRES_JOIN_CITY:
2408 if (actor_unittype->pop_cost <= 0 && !is_super_specialist(actor_unittype->spec_type)) {
2409 /* Reason: Must have something to add. */
2410 return FALSE;
2411 }
2412 break;
2413
2414 case ACTRES_BOMBARD:
2415 if (actor_unittype->bombard_rate <= 0) {
2416 /* Reason: Can't bombard if it never fires. */
2417 return FALSE;
2418 }
2419
2420 if (actor_unittype->attack_strength <= 0) {
2421 /* Reason: Can't bombard without attack strength. */
2422 return FALSE;
2423 }
2424
2425 break;
2426
2427 case ACTRES_UPGRADE_UNIT:
2428 if (actor_unittype->obsoleted_by == U_NOT_OBSOLETED) {
2429 /* Reason: Nothing to upgrade to. */
2430 return FALSE;
2431 }
2432 break;
2433
2434 case ACTRES_ATTACK:
2435 case ACTRES_WIPE_UNITS:
2436 case ACTRES_COLLECT_RANSOM:
2437 if (actor_unittype->attack_strength <= 0) {
2438 /* Reason: Can't attack without strength. */
2439 return FALSE;
2440 }
2441 break;
2442
2443 case ACTRES_CONVERT:
2444 if (!actor_unittype->converted_to) {
2445 /* Reason: must be able to convert to something. */
2446 return FALSE;
2447 }
2448 break;
2449
2450 case ACTRES_TRANSPORT_UNLOAD:
2451 if (actor_unittype->transport_capacity < 1) {
2452 /* Reason: can't transport anything to unload. */
2453 return FALSE;
2454 }
2455 break;
2456
2457 case ACTRES_TRANSPORT_LOAD:
2458 if (actor_unittype->transport_capacity < 1) {
2459 /* Reason: can't transport anything to load. */
2460 return FALSE;
2461 }
2462 break;
2463
2464 case ACTRES_TRANSPORT_BOARD:
2465 case ACTRES_TRANSPORT_EMBARK:
2466 case ACTRES_TRANSPORT_DEBOARD:
2467 case ACTRES_TRANSPORT_DISEMBARK:
2468 if (!ignore_third_party) {
2469 bool has_transporter = FALSE;
2470
2471 unit_type_iterate(utrans) {
2472 if (can_unit_type_transport(utrans, utype_class(actor_unittype))) {
2473 has_transporter = TRUE;
2474 break;
2475 }
2476 } unit_type_iterate_end;
2477
2478 if (!has_transporter) {
2479 /* Reason: no other unit can transport this unit. */
2480 return FALSE;
2481 }
2482 }
2483 break;
2484
2485 case ACTRES_CONQUER_EXTRAS:
2486 if (!ignore_third_party) {
2487 bool has_target = FALSE;
2488 struct unit_class *pclass = utype_class(actor_unittype);
2489
2490 /* Use cache when it has been initialized */
2491 if (pclass->cache.native_bases != nullptr) {
2492 /* Extra being native one is a hard requirement */
2493 extra_type_list_iterate(pclass->cache.native_bases, pextra) {
2494 if (!territory_claiming_base(pextra->data.base)) {
2495 /* Hard requirement */
2496 continue;
2497 }
2498
2499 has_target = TRUE;
2500 break;
2501 } extra_type_list_iterate_end;
2502 } else {
2503 struct extra_type_list *terr_claimers = extra_type_list_of_terr_claimers();
2504
2505 extra_type_list_iterate(terr_claimers, pextra) {
2506 if (!is_native_extra_to_uclass(pextra, pclass)) {
2507 /* Hard requirement */
2508 continue;
2509 }
2510
2511 has_target = TRUE;
2512 break;
2513 } extra_type_list_iterate_end;
2514 }
2515
2516 if (!has_target) {
2517 /* Reason: no extras can be conquered by this unit. */
2518 return FALSE;
2519 }
2520 }
2521 break;
2522
2523 case ACTRES_PARADROP:
2524 case ACTRES_PARADROP_CONQUER:
2525 if (actor_unittype->paratroopers_range <= 0) {
2526 /* Reason: Can't paradrop 0 tiles. */
2527 return FALSE;
2528 }
2529 break;
2530
2531 case ACTRES_HUT_ENTER:
2532 case ACTRES_HUT_FRIGHTEN:
2533 case ACTRES_ESTABLISH_EMBASSY:
2534 case ACTRES_SPY_INVESTIGATE_CITY:
2535 case ACTRES_SPY_POISON:
2536 case ACTRES_SPY_STEAL_GOLD:
2537 case ACTRES_SPY_SPREAD_PLAGUE:
2538 case ACTRES_SPY_SABOTAGE_CITY:
2539 case ACTRES_SPY_TARGETED_SABOTAGE_CITY:
2540 case ACTRES_SPY_SABOTAGE_CITY_PRODUCTION:
2541 case ACTRES_SPY_STEAL_TECH:
2542 case ACTRES_SPY_TARGETED_STEAL_TECH:
2543 case ACTRES_SPY_INCITE_CITY:
2544 case ACTRES_SPY_ESCAPE:
2545 case ACTRES_TRADE_ROUTE:
2546 case ACTRES_MARKETPLACE:
2547 case ACTRES_HELP_WONDER:
2548 case ACTRES_SPY_BRIBE_UNIT:
2549 case ACTRES_SPY_BRIBE_STACK:
2550 case ACTRES_SPY_SABOTAGE_UNIT:
2551 case ACTRES_CAPTURE_UNITS:
2552 case ACTRES_FOUND_CITY:
2553 case ACTRES_STEAL_MAPS:
2554 case ACTRES_SPY_NUKE:
2555 case ACTRES_NUKE:
2556 case ACTRES_NUKE_UNITS:
2557 case ACTRES_DESTROY_CITY:
2558 case ACTRES_EXPEL_UNIT:
2559 case ACTRES_DISBAND_UNIT_RECOVER:
2560 case ACTRES_DISBAND_UNIT:
2561 case ACTRES_HOME_CITY:
2562 case ACTRES_HOMELESS:
2563 case ACTRES_AIRLIFT:
2564 case ACTRES_STRIKE_BUILDING:
2565 case ACTRES_STRIKE_PRODUCTION:
2566 case ACTRES_CONQUER_CITY:
2567 case ACTRES_HEAL_UNIT:
2568 case ACTRES_PILLAGE:
2569 case ACTRES_CLEAN:
2570 case ACTRES_FORTIFY:
2571 case ACTRES_TRANSFORM_TERRAIN:
2572 case ACTRES_CULTIVATE:
2573 case ACTRES_PLANT:
2574 case ACTRES_ROAD:
2575 case ACTRES_BASE:
2576 case ACTRES_MINE:
2577 case ACTRES_IRRIGATE:
2578 case ACTRES_SPY_ATTACK:
2579 case ACTRES_UNIT_MOVE:
2580 case ACTRES_TELEPORT:
2581 case ACTRES_TELEPORT_CONQUER:
2582 case ACTRES_SCOUT:
2583 case ACTRES_ENABLER_CHECK:
2584 case ACTRES_NONE:
2585 /* No hard unit type requirements. */
2586 break;
2587
2588 ASSERT_UNUSED_ACTRES_CASES;
2589 }
2590
2591 return TRUE;
2592}
2593
2594/**********************************************************************/
2610bool
2617
2618/**********************************************************************/
2630static enum fc_tristate
2631action_hard_reqs_actor(const struct civ_map *nmap,
2632 const struct action *paction,
2633 const struct req_context *actor,
2634 const bool omniscient,
2635 const struct city *homecity)
2636{
2637 enum action_result result = paction->result;
2638
2639 if (actor == nullptr) {
2640 actor = req_context_empty();
2641 }
2642
2643 if (!action_actor_utype_hard_reqs_ok_full(paction, actor->unittype,
2644 TRUE)) {
2645 /* Info leak: The actor player knows the type of their unit. */
2646 /* The actor unit type can't perform the action because of hard
2647 * unit type requirements. */
2648 return TRI_NO;
2649 }
2650
2651 switch (result) {
2652 case ACTRES_PARADROP:
2653 case ACTRES_PARADROP_CONQUER:
2654 /* Reason: Keep the old rules. */
2655 /* Info leak: The player knows if their unit already has paradropped this
2656 * turn. */
2657 if (actor->unit->paradropped) {
2658 return TRI_NO;
2659 }
2660
2661 break;
2662
2663 case ACTRES_AIRLIFT:
2664 {
2665 /* Obligatory hard requirement. Checked here too since
2666 * action_hard_reqs_actor() may be called before any
2667 * action enablers are checked. */
2668 if (actor->city == nullptr) {
2669 /* No city to airlift from. */
2670 return TRI_NO;
2671 }
2672
2673 if (actor->player != city_owner(actor->city)
2674 && !(game.info.airlifting_style & AIRLIFTING_ALLIED_SRC
2675 && pplayers_allied(actor->player,
2676 city_owner(actor->city)))) {
2677 /* Not allowed to airlift from this source. */
2678 return TRI_NO;
2679 }
2680
2681 if (!(omniscient || city_owner(actor->city) == actor->player)) {
2682 /* Can't check for airlifting capacity. */
2683 return TRI_MAYBE;
2684 }
2685
2686 if (0 >= actor->city->airlift
2687 && (!(game.info.airlifting_style & AIRLIFTING_UNLIMITED_SRC)
2688 || !game.info.airlift_from_always_enabled)) {
2689 /* The source cannot airlift for this turn (maybe already airlifted
2690 * or no airport).
2691 *
2692 * See also do_airline() in server/unittools.h. */
2693 return TRI_NO;
2694 }
2695 }
2696 break;
2697
2698 case ACTRES_CONVERT:
2699 /* Reason: Keep the old rules. */
2700 /* Info leak: The player knows their unit's cargo and location. */
2701 if (!unit_can_convert(nmap, actor->unit)) {
2702 return TRI_NO;
2703 }
2704 break;
2705
2706 case ACTRES_TRANSPORT_BOARD:
2707 case ACTRES_TRANSPORT_EMBARK:
2708 if (unit_transported(actor->unit)) {
2709 if (!can_unit_unload(actor->unit, unit_transport_get(actor->unit))) {
2710 /* Can't leave current transport. */
2711 return TRI_NO;
2712 }
2713 }
2714 break;
2715
2716 case ACTRES_TRANSPORT_DISEMBARK:
2717 if (!can_unit_unload(actor->unit, unit_transport_get(actor->unit))) {
2718 /* Keep the old rules about Unreachable and disembarks. */
2719 return TRI_NO;
2720 }
2721 break;
2722
2723 case ACTRES_HOMELESS:
2724 case ACTRES_UNIT_MOVE:
2725 case ACTRES_TELEPORT:
2726 case ACTRES_TELEPORT_CONQUER:
2727 case ACTRES_ESTABLISH_EMBASSY:
2728 case ACTRES_SPY_INVESTIGATE_CITY:
2729 case ACTRES_SPY_POISON:
2730 case ACTRES_SPY_STEAL_GOLD:
2731 case ACTRES_SPY_SPREAD_PLAGUE:
2732 case ACTRES_SPY_SABOTAGE_CITY:
2733 case ACTRES_SPY_TARGETED_SABOTAGE_CITY:
2734 case ACTRES_SPY_SABOTAGE_CITY_PRODUCTION:
2735 case ACTRES_SPY_STEAL_TECH:
2736 case ACTRES_SPY_TARGETED_STEAL_TECH:
2737 case ACTRES_SPY_INCITE_CITY:
2738 case ACTRES_SPY_ESCAPE:
2739 case ACTRES_TRADE_ROUTE:
2740 case ACTRES_MARKETPLACE:
2741 case ACTRES_HELP_WONDER:
2742 case ACTRES_SPY_BRIBE_UNIT:
2743 case ACTRES_SPY_BRIBE_STACK:
2744 case ACTRES_SPY_SABOTAGE_UNIT:
2745 case ACTRES_CAPTURE_UNITS:
2746 case ACTRES_FOUND_CITY:
2747 case ACTRES_JOIN_CITY:
2748 case ACTRES_STEAL_MAPS:
2749 case ACTRES_BOMBARD:
2750 case ACTRES_SPY_NUKE:
2751 case ACTRES_NUKE:
2752 case ACTRES_NUKE_UNITS:
2753 case ACTRES_DESTROY_CITY:
2754 case ACTRES_EXPEL_UNIT:
2755 case ACTRES_DISBAND_UNIT_RECOVER:
2756 case ACTRES_DISBAND_UNIT:
2757 case ACTRES_HOME_CITY:
2758 case ACTRES_UPGRADE_UNIT:
2759 case ACTRES_ATTACK:
2760 case ACTRES_WIPE_UNITS:
2761 case ACTRES_COLLECT_RANSOM:
2762 case ACTRES_STRIKE_BUILDING:
2763 case ACTRES_STRIKE_PRODUCTION:
2764 case ACTRES_CONQUER_CITY:
2765 case ACTRES_CONQUER_EXTRAS:
2766 case ACTRES_HEAL_UNIT:
2767 case ACTRES_TRANSFORM_TERRAIN:
2768 case ACTRES_CULTIVATE:
2769 case ACTRES_PLANT:
2770 case ACTRES_PILLAGE:
2771 case ACTRES_CLEAN:
2772 case ACTRES_FORTIFY:
2773 case ACTRES_ROAD:
2774 case ACTRES_BASE:
2775 case ACTRES_MINE:
2776 case ACTRES_IRRIGATE:
2777 case ACTRES_TRANSPORT_DEBOARD:
2778 case ACTRES_TRANSPORT_UNLOAD:
2779 case ACTRES_TRANSPORT_LOAD:
2780 case ACTRES_SPY_ATTACK:
2781 case ACTRES_HUT_ENTER:
2782 case ACTRES_HUT_FRIGHTEN:
2783 case ACTRES_SCOUT:
2784 case ACTRES_ENABLER_CHECK:
2785 case ACTRES_NONE:
2786 /* No hard unit requirements. */
2787 break;
2788
2789 ASSERT_UNUSED_ACTRES_CASES;
2790 }
2791
2792 return TRI_YES;
2793}
2794
2795/**********************************************************************/
2818static enum fc_tristate
2819is_action_possible(const struct civ_map *nmap,
2820 const action_id wanted_action,
2821 const struct req_context *actor,
2822 const struct req_context *target,
2823 const struct extra_type *target_extra,
2824 const bool omniscient,
2825 const struct city *homecity)
2826{
2827 enum fc_tristate out;
2828 struct action *paction = action_by_number(wanted_action);
2829 enum action_target_kind tkind = action_get_target_kind(paction);
2830 const struct tile *atile = nullptr, *ttile = nullptr;
2831
2832 if (actor == nullptr) {
2833 actor = req_context_empty();
2834 } else {
2835 atile = actor->tile;
2836 }
2837 if (target == nullptr) {
2838 target = req_context_empty();
2839 } else {
2840 ttile = target->tile;
2841 }
2842
2843 fc_assert_msg((tkind == ATK_CITY && target->city != nullptr)
2844 || (tkind == ATK_TILE && ttile != nullptr)
2845 || (tkind == ATK_EXTRAS && ttile != nullptr)
2846 || (tkind == ATK_UNIT && target->unit != nullptr)
2847 /* At this level each individual unit is tested. */
2848 || (tkind == ATK_STACK && target->unit != nullptr)
2849 || (tkind == ATK_SELF),
2850 "Missing target!");
2851
2852 /* Info leak: The player knows where their unit/city is. */
2853 if (nullptr != atile && nullptr != ttile
2854 && !action_distance_accepted(paction,
2855 real_map_distance(atile, ttile))) {
2856 /* The distance between the actor and the target isn't inside the
2857 * action's accepted range. */
2858 return TRI_NO;
2859 }
2860
2861 switch (tkind) {
2862 case ATK_UNIT:
2863 /* The Freeciv code for all actions that is controlled by action
2864 * enablers and targets a unit assumes that the acting
2865 * player can see the target unit.
2866 * Examples:
2867 * - action_prob_vs_unit()'s quick check that the distance between actor
2868 * and target is acceptable would leak distance to target unit if the
2869 * target unit can't be seen.
2870 */
2871 if (!can_player_see_unit(actor->player, target->unit)) {
2872 return TRI_NO;
2873 }
2874 break;
2875 case ATK_CITY:
2876 /* The Freeciv code assumes that the player is aware of the target
2877 * city's existence. (How can you order an airlift to a city when you
2878 * don't know its city ID?) */
2879 if (fc_funcs->player_tile_city_id_get(city_tile(target->city),
2880 actor->player)
2881 != target->city->id) {
2882 return TRI_NO;
2883 }
2884 break;
2885 case ATK_STACK:
2886 case ATK_TILE:
2887 case ATK_EXTRAS:
2888 case ATK_SELF:
2889 /* No special player knowledge checks. */
2890 break;
2891 case ATK_COUNT:
2892 fc_assert(tkind != ATK_COUNT);
2893 break;
2894 }
2895
2896 if (action_is_blocked_by(nmap, paction, actor->unit,
2897 ttile, target->city, target->unit)) {
2898 /* Allows an action to block an other action. If a blocking action is
2899 * legal the actions it blocks becomes illegal. */
2900 return TRI_NO;
2901 }
2902
2903 /* Actor specific hard requirements. */
2904 out = action_hard_reqs_actor(nmap, paction, actor, omniscient, homecity);
2905
2906 if (out == TRI_NO) {
2907 /* Illegal because of a hard actor requirement. */
2908 return TRI_NO;
2909 }
2910
2911 /* Quick checks for action itself */
2912 if (paction->result == ACTRES_ATTACK
2913 || paction->result == ACTRES_WIPE_UNITS
2914 || paction->result == ACTRES_COLLECT_RANSOM) {
2915 /* Reason: Keep the old rules. */
2916 if (!can_unit_attack_tile(actor->unit, paction, ttile)) {
2917 return TRI_NO;
2918 }
2919 }
2920
2921 /* Hard requirements for results. */
2922 out = actres_possible(nmap,
2923 paction->result, actor,
2924 target, target_extra, out, omniscient,
2925 homecity);
2926
2927 if (out == TRI_NO) {
2928 /* Illegal because of a hard actor requirement. */
2929 return TRI_NO;
2930 }
2931
2932 if (paction->result == ACTRES_NUKE_UNITS) {
2933 if (unit_attack_units_at_tile_result(actor->unit, paction, ttile)
2934 != ATT_OK) {
2935 /* Unreachable. */
2936 return TRI_NO;
2937 }
2938 } else if (paction->result == ACTRES_PARADROP
2939 || paction->result == ACTRES_PARADROP_CONQUER) {
2940 if (can_player_see_tile(actor->player, ttile)) {
2941 /* Check for seen stuff that may kill the actor unit. */
2942
2943 /* Reason: Keep the old rules. Be merciful. */
2944 /* Info leak: The player sees the target tile. */
2945 if (!can_unit_exist_at_tile(nmap, actor->unit, ttile)
2946 && (!BV_ISSET(paction->sub_results, ACT_SUB_RES_MAY_EMBARK)
2947 || !unit_could_load_at(actor->unit, ttile))) {
2948 return TRI_NO;
2949 }
2950
2951 /* Reason: Keep the old rules. Be merciful. */
2952 /* Info leak: The player sees the target tile. */
2953 if (is_non_attack_city_tile(ttile, actor->player)) {
2954 return TRI_NO;
2955 }
2956
2957 /* Reason: Be merciful. */
2958 /* Info leak: The player sees all units checked. Invisible units are
2959 * ignored. */
2960 unit_list_iterate(ttile->units, pother) {
2961 if (can_player_see_unit(actor->player, pother)
2962 && !pplayers_allied(actor->player, unit_owner(pother))) {
2963 return TRI_NO;
2964 }
2965 } unit_list_iterate_end;
2966 }
2967 }
2968
2969 return out;
2970}
2971
2972/**********************************************************************/
2978static bool is_enabler_active(const struct action_enabler *enabler,
2979 const struct req_context *actor,
2980 const struct req_context *target)
2981{
2982 return are_reqs_active(actor, target, &enabler->actor_reqs, RPT_CERTAIN)
2983 && are_reqs_active(target, actor, &enabler->target_reqs, RPT_CERTAIN);
2984}
2985
2986/**********************************************************************/
2995static bool is_action_enabled(const struct civ_map *nmap,
2996 const action_id wanted_action,
2997 const struct req_context *actor,
2998 const struct req_context *target,
2999 const struct extra_type *target_extra,
3000 const struct city *actor_home)
3001{
3002 enum fc_tristate possible;
3003
3004 possible = is_action_possible(nmap, wanted_action, actor, target, target_extra,
3005 TRUE, actor_home);
3006
3007 if (possible != TRI_YES) {
3008 /* This context is omniscient. Should be yes or no. */
3009 fc_assert_msg(possible != TRI_MAYBE,
3010 "Is omniscient, should get yes or no.");
3011
3012 /* The action enablers are irrelevant since the action it self is
3013 * impossible. */
3014 return FALSE;
3015 }
3016
3017 return action_enablers_allow(wanted_action, actor, target);
3018}
3019
3020/**********************************************************************/
3024bool action_enablers_allow(const action_id wanted_action,
3025 const struct req_context *actor,
3026 const struct req_context *target)
3027{
3028 action_enabler_list_iterate(action_enablers_for_action(wanted_action),
3029 enabler) {
3030 if (is_enabler_active(enabler, actor, target)) {
3031 return TRUE;
3032 }
3033 } action_enabler_list_iterate_end;
3034
3035 return FALSE;
3036}
3037
3038/**********************************************************************/
3044static bool
3045is_action_enabled_unit_on_city_full(const struct civ_map *nmap,
3046 const action_id wanted_action,
3047 const struct unit *actor_unit,
3048 const struct city *actor_home,
3049 const struct tile *actor_tile,
3050 const struct city *target_city)
3051{
3052 const struct impr_type *target_building;
3053 const struct unit_type *target_utype;
3054
3055 if (actor_unit == nullptr || target_city == nullptr) {
3056 /* Can't do an action when actor or target are missing. */
3057 return FALSE;
3058 }
3059
3060 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3061 FALSE, "Action %s is performed by %s not %s",
3062 action_id_rule_name(wanted_action),
3063 action_actor_kind_name(
3064 action_id_get_actor_kind(wanted_action)),
3065 action_actor_kind_name(AAK_UNIT));
3066
3067 fc_assert_ret_val_msg(ATK_CITY
3068 == action_id_get_target_kind(wanted_action),
3069 FALSE, "Action %s is against %s not %s",
3070 action_id_rule_name(wanted_action),
3071 action_target_kind_name(
3072 action_id_get_target_kind(wanted_action)),
3073 action_target_kind_name(ATK_CITY));
3074
3075 fc_assert_ret_val(actor_tile, FALSE);
3076
3077 if (!unit_can_do_action(actor_unit, wanted_action)) {
3078 /* No point in continuing. */
3079 return FALSE;
3080 }
3081
3082 target_building = tgt_city_local_building(target_city);
3083 target_utype = tgt_city_local_utype(target_city);
3084
3085 return is_action_enabled(nmap, wanted_action,
3086 &(const struct req_context) {
3087 .player = unit_owner(actor_unit),
3088 .city = tile_city(actor_tile),
3089 .tile = actor_tile,
3090 .unit = actor_unit,
3091 .unittype = unit_type_get(actor_unit),
3092 },
3093 &(const struct req_context) {
3094 .player = city_owner(target_city),
3095 .city = target_city,
3096 .building = target_building,
3097 .tile = city_tile(target_city),
3098 .unittype = target_utype,
3099 },
3100 nullptr,
3101 actor_home);
3102}
3103
3104/**********************************************************************/
3120
3121/**********************************************************************/
3127static bool
3128is_action_enabled_unit_on_unit_full(const struct civ_map *nmap,
3129 const action_id wanted_action,
3130 const struct unit *actor_unit,
3131 const struct city *actor_home,
3132 const struct tile *actor_tile,
3133 const struct unit *target_unit)
3134{
3135 if (actor_unit == nullptr || target_unit == nullptr) {
3136 /* Can't do an action when actor or target are missing. */
3137 return FALSE;
3138 }
3139
3140 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3141 FALSE, "Action %s is performed by %s not %s",
3142 action_id_rule_name(wanted_action),
3143 action_actor_kind_name(
3144 action_id_get_actor_kind(wanted_action)),
3145 action_actor_kind_name(AAK_UNIT));
3146
3147 fc_assert_ret_val_msg(ATK_UNIT
3148 == action_id_get_target_kind(wanted_action),
3149 FALSE, "Action %s is against %s not %s",
3150 action_id_rule_name(wanted_action),
3151 action_target_kind_name(
3152 action_id_get_target_kind(wanted_action)),
3153 action_target_kind_name(ATK_UNIT));
3154
3155 fc_assert_ret_val(actor_tile, FALSE);
3156
3157 if (!unit_can_do_action(actor_unit, wanted_action)) {
3158 /* No point in continuing. */
3159 return FALSE;
3160 }
3161
3162 return is_action_enabled(nmap, wanted_action,
3163 &(const struct req_context) {
3164 .player = unit_owner(actor_unit),
3165 .city = tile_city(actor_tile),
3166 .tile = actor_tile,
3167 .unit = actor_unit,
3168 .unittype = unit_type_get(actor_unit),
3169 },
3170 &(const struct req_context) {
3171 .player = unit_owner(target_unit),
3172 .city = tile_city(unit_tile(target_unit)),
3173 .tile = unit_tile(target_unit),
3174 .unit = target_unit,
3175 .unittype = unit_type_get(target_unit),
3176 },
3177 nullptr,
3178 actor_home);
3179}
3180
3181/**********************************************************************/
3197
3198/**********************************************************************/
3204static bool
3205is_action_enabled_unit_on_stack_full(const struct civ_map *nmap,
3206 const action_id wanted_action,
3207 const struct unit *actor_unit,
3208 const struct city *actor_home,
3209 const struct tile *actor_tile,
3210 const struct tile *target_tile)
3211{
3212 const struct req_context *actor_ctxt;
3213
3214 if (actor_unit == nullptr || target_tile == nullptr
3215 || unit_list_size(target_tile->units) == 0) {
3216 /* Can't do an action when actor or target are missing. */
3217 return FALSE;
3218 }
3219
3220 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3221 FALSE, "Action %s is performed by %s not %s",
3222 action_id_rule_name(wanted_action),
3223 action_actor_kind_name(
3224 action_id_get_actor_kind(wanted_action)),
3225 action_actor_kind_name(AAK_UNIT));
3226
3227 fc_assert_ret_val_msg(ATK_STACK
3228 == action_id_get_target_kind(wanted_action),
3229 FALSE, "Action %s is against %s not %s",
3230 action_id_rule_name(wanted_action),
3231 action_target_kind_name(
3232 action_id_get_target_kind(wanted_action)),
3233 action_target_kind_name(ATK_STACK));
3234
3235 fc_assert_ret_val(actor_tile, FALSE);
3236
3237 if (!unit_can_do_action(actor_unit, wanted_action)) {
3238 /* No point in continuing. */
3239 return FALSE;
3240 }
3241
3242 actor_ctxt = &(const struct req_context) {
3243 .player = unit_owner(actor_unit),
3244 .city = tile_city(actor_tile),
3245 .tile = actor_tile,
3246 .unit = actor_unit,
3247 .unittype = unit_type_get(actor_unit),
3248 };
3249
3250 unit_list_iterate(target_tile->units, target_unit) {
3251 if (!is_action_enabled(nmap, wanted_action, actor_ctxt,
3252 &(const struct req_context) {
3253 .player = unit_owner(target_unit),
3254 .city = tile_city(unit_tile(target_unit)),
3255 .tile = unit_tile(target_unit),
3256 .unit = target_unit,
3257 .unittype = unit_type_get(target_unit),
3258 },
3259 nullptr, actor_home)) {
3260 /* One unit makes it impossible for all units. */
3261 return FALSE;
3262 }
3263 } unit_list_iterate_end;
3264
3265 /* Not impossible for any of the units at the tile. */
3266 return TRUE;
3267}
3268
3269/**********************************************************************/
3285
3286/**********************************************************************/
3292static bool
3293is_action_enabled_unit_on_tile_full(const struct civ_map *nmap,
3294 const action_id wanted_action,
3295 const struct unit *actor_unit,
3296 const struct city *actor_home,
3297 const struct tile *actor_tile,
3298 const struct tile *target_tile,
3299 const struct extra_type *target_extra)
3300{
3301 if (actor_unit == nullptr || target_tile == nullptr) {
3302 /* Can't do an action when actor or target are missing. */
3303 return FALSE;
3304 }
3305
3306 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3307 FALSE, "Action %s is performed by %s not %s",
3308 action_id_rule_name(wanted_action),
3309 action_actor_kind_name(
3310 action_id_get_actor_kind(wanted_action)),
3311 action_actor_kind_name(AAK_UNIT));
3312
3313 fc_assert_ret_val_msg(ATK_TILE
3314 == action_id_get_target_kind(wanted_action),
3315 FALSE, "Action %s is against %s not %s",
3316 action_id_rule_name(wanted_action),
3317 action_target_kind_name(
3318 action_id_get_target_kind(wanted_action)),
3319 action_target_kind_name(ATK_TILE));
3320
3321 fc_assert_ret_val(actor_tile, FALSE);
3322
3323 if (!unit_can_do_action(actor_unit, wanted_action)) {
3324 /* No point in continuing. */
3325 return FALSE;
3326 }
3327
3328 return is_action_enabled(nmap, wanted_action,
3329 &(const struct req_context) {
3330 .player = unit_owner(actor_unit),
3331 .city = tile_city(actor_tile),
3332 .tile = actor_tile,
3333 .unit = actor_unit,
3334 .unittype = unit_type_get(actor_unit),
3335 },
3336 &(const struct req_context) {
3337 .player = tile_owner(target_tile),
3338 .city = tile_city(target_tile),
3339 .tile = target_tile,
3340 },
3341 target_extra,
3342 actor_home);
3343}
3344
3345/**********************************************************************/
3351bool is_action_enabled_unit_on_tile(const struct civ_map *nmap,
3352 const action_id wanted_action,
3353 const struct unit *actor_unit,
3354 const struct tile *target_tile,
3355 const struct extra_type *target_extra)
3356{
3357 return is_action_enabled_unit_on_tile_full(nmap, wanted_action, actor_unit,
3358 unit_home(actor_unit),
3359 unit_tile(actor_unit),
3360 target_tile, target_extra);
3361}
3362
3363/**********************************************************************/
3369static bool
3370is_action_enabled_unit_on_extras_full(const struct civ_map *nmap,
3371 const action_id wanted_action,
3372 const struct unit *actor_unit,
3373 const struct city *actor_home,
3374 const struct tile *actor_tile,
3375 const struct tile *target_tile,
3376 const struct extra_type *target_extra)
3377{
3378 if (actor_unit == nullptr || target_tile == nullptr) {
3379 /* Can't do an action when actor or target are missing. */
3380 return FALSE;
3381 }
3382
3383 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3384 FALSE, "Action %s is performed by %s not %s",
3385 action_id_rule_name(wanted_action),
3386 action_actor_kind_name(
3387 action_id_get_actor_kind(wanted_action)),
3388 action_actor_kind_name(AAK_UNIT));
3389
3390 fc_assert_ret_val_msg(ATK_EXTRAS
3391 == action_id_get_target_kind(wanted_action),
3392 FALSE, "Action %s is against %s not %s",
3393 action_id_rule_name(wanted_action),
3394 action_target_kind_name(
3395 action_id_get_target_kind(wanted_action)),
3396 action_target_kind_name(ATK_EXTRAS));
3397
3398 fc_assert_ret_val(actor_tile, FALSE);
3399
3400 if (!unit_can_do_action(actor_unit, wanted_action)) {
3401 /* No point in continuing. */
3402 return FALSE;
3403 }
3404
3405 return is_action_enabled(nmap, wanted_action,
3406 &(const struct req_context) {
3407 .player = unit_owner(actor_unit),
3408 .city = tile_city(actor_tile),
3409 .tile = actor_tile,
3410 .unit = actor_unit,
3411 .unittype = unit_type_get(actor_unit),
3412 },
3413 &(const struct req_context) {
3414 .player = target_tile->extras_owner,
3415 .city = tile_city(target_tile),
3416 .tile = target_tile,
3417 },
3418 target_extra,
3419 actor_home);
3420}
3421
3422/**********************************************************************/
3439
3440/**********************************************************************/
3447static bool
3448is_action_enabled_unit_on_self_full(const struct civ_map *nmap,
3449 const action_id wanted_action,
3450 const struct unit *actor_unit,
3451 const struct city *actor_home,
3452 const struct tile *actor_tile)
3453{
3454 if (actor_unit == nullptr) {
3455 /* Can't do an action when the actor is missing. */
3456 return FALSE;
3457 }
3458
3459 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(wanted_action),
3460 FALSE, "Action %s is performed by %s not %s",
3461 action_id_rule_name(wanted_action),
3462 action_actor_kind_name(
3463 action_id_get_actor_kind(wanted_action)),
3464 action_actor_kind_name(AAK_UNIT));
3465
3466 fc_assert_ret_val_msg(ATK_SELF
3467 == action_id_get_target_kind(wanted_action),
3468 FALSE, "Action %s is against %s not %s",
3469 action_id_rule_name(wanted_action),
3470 action_target_kind_name(
3471 action_id_get_target_kind(wanted_action)),
3472 action_target_kind_name(ATK_SELF));
3473
3474 fc_assert_ret_val(actor_tile, FALSE);
3475
3476 if (!unit_can_do_action(actor_unit, wanted_action)) {
3477 /* No point in continuing. */
3478 return FALSE;
3479 }
3480
3481 return is_action_enabled(nmap, wanted_action,
3482 &(const struct req_context) {
3483 .player = unit_owner(actor_unit),
3484 .city = tile_city(actor_tile),
3485 .tile = actor_tile,
3486 .unit = actor_unit,
3487 .unittype = unit_type_get(actor_unit),
3488 },
3489 nullptr, nullptr,
3490 actor_home);
3491}
3492
3493/**********************************************************************/
3508
3509#define ASSERT_PLAYER_ACTION(_atk) \
3510 fc_assert_ret_val_msg(AAK_PLAYER == action_id_get_actor_kind(wanted_action),\
3511 FALSE, "Action %s is performed by %s not %s", \
3512 action_id_rule_name(wanted_action), \
3513 action_actor_kind_name( \
3514 action_id_get_actor_kind(wanted_action)), \
3515 action_actor_kind_name(AAK_PLAYER)); \
3516 fc_assert_ret_val_msg(_atk \
3517 == action_id_get_target_kind(wanted_action), \
3518 FALSE, "Action %s is against %s not %s", \
3519 action_id_rule_name(wanted_action), \
3520 action_target_kind_name( \
3521 action_id_get_target_kind(wanted_action)), \
3522 action_target_kind_name(_atk));
3523
3524/**********************************************************************/
3528bool is_action_enabled_player_on_self(const struct civ_map *nmap,
3529 const action_id wanted_action,
3530 const struct player *actor_plr)
3531{
3532 if (actor_plr == nullptr) {
3533 /* Can't do an action when the actor is missing. */
3534 return FALSE;
3535 }
3536
3537 ASSERT_PLAYER_ACTION(ATK_SELF);
3538
3539 return is_action_enabled(nmap, wanted_action,
3540 &(const struct req_context) {
3541 .player = actor_plr,
3542 },
3543 nullptr, nullptr, nullptr);
3544}
3545
3546/**********************************************************************/
3550bool is_action_enabled_player_on_city(const struct civ_map *nmap,
3551 const action_id wanted_action,
3552 const struct player *actor_plr,
3553 const struct city *target_city)
3554{
3555 const struct impr_type *target_building;
3556 const struct unit_type *target_utype;
3557
3558 if (actor_plr == nullptr || target_city == nullptr) {
3559 /* Can't do an action when the actor or the target is missing. */
3560 return FALSE;
3561 }
3562
3563 ASSERT_PLAYER_ACTION(ATK_CITY);
3564
3565 target_building = tgt_city_local_building(target_city);
3566 target_utype = tgt_city_local_utype(target_city);
3567
3568 return is_action_enabled(nmap, wanted_action,
3569 &(const struct req_context) {
3570 .player = actor_plr,
3571 },
3572 &(const struct req_context) {
3573 .player = city_owner(target_city),
3574 .city = target_city,
3575 .building = target_building,
3576 .tile = city_tile(target_city),
3577 .unittype = target_utype,
3578 }, nullptr, nullptr);
3579}
3580
3581/**********************************************************************/
3587bool
3588is_action_enabled_player_on_extras(const struct civ_map *nmap,
3589 const action_id wanted_action,
3590 const struct player *actor_plr,
3591 const struct tile *target_tile,
3592 const struct extra_type *target_extra)
3593{
3594 if (actor_plr == nullptr || target_tile == nullptr) {
3595 /* Can't do an action when actor or target are missing. */
3596 return FALSE;
3597 }
3598
3599 ASSERT_PLAYER_ACTION(ATK_EXTRAS);
3600
3601 return is_action_enabled(nmap, wanted_action,
3602 &(const struct req_context) {
3603 .player = actor_plr,
3604 },
3605 &(const struct req_context) {
3606 .player = target_tile->extras_owner,
3607 .city = tile_city(target_tile),
3608 .tile = target_tile,
3609 },
3610 target_extra, nullptr);
3611}
3612
3613/**********************************************************************/
3619bool is_action_enabled_player_on_stack(const struct civ_map *nmap,
3620 const action_id wanted_action,
3621 const struct player *actor_plr,
3622 const struct tile *target_tile,
3623 const struct extra_type *target_extra)
3624{
3625 const struct req_context actor_ctxt = {
3626 .player = actor_plr,
3627 };
3628 const struct city *tcity;
3629
3630 if (actor_plr == nullptr || target_tile == nullptr
3631 || unit_list_size(target_tile->units) == 0) {
3632 /* Can't do an action when actor or target are missing. */
3633 return FALSE;
3634 }
3635
3636 ASSERT_PLAYER_ACTION(ATK_STACK);
3637
3638 tcity = tile_city(target_tile);
3639 unit_list_iterate(target_tile->units, target_unit) {
3640 if (!is_action_enabled(nmap, wanted_action, &actor_ctxt,
3641 &(const struct req_context) {
3642 .player = unit_owner(target_unit),
3643 .city = tcity,
3644 .tile = target_tile,
3645 .unit = target_unit,
3646 .unittype = unit_type_get(target_unit),
3647 },
3648 nullptr, nullptr)) {
3649 /* One unit makes it impossible for all units. */
3650 return FALSE;
3651 }
3652 } unit_list_iterate_end;
3653
3654 /* Not impossible for any of the units at the tile. */
3655 return TRUE;
3656}
3657
3658/**********************************************************************/
3664bool is_action_enabled_player_on_tile(const struct civ_map *nmap,
3665 const action_id wanted_action,
3666 const struct player *actor_plr,
3667 const struct tile *target_tile,
3668 const struct extra_type *target_extra)
3669{
3670 if (actor_plr == nullptr || target_tile == nullptr) {
3671 /* Can't do an action when actor or target are missing. */
3672 return FALSE;
3673 }
3674
3675 ASSERT_PLAYER_ACTION(ATK_TILE);
3676
3677 return is_action_enabled(nmap, wanted_action,
3678 &(const struct req_context) {
3679 .player = actor_plr,
3680 },
3681 &(const struct req_context) {
3682 .player = tile_owner(target_tile),
3683 .city = tile_city(target_tile),
3684 .tile = target_tile,
3685 },
3686 target_extra, nullptr);
3687}
3688
3689/**********************************************************************/
3695bool is_action_enabled_player_on_unit(const struct civ_map *nmap,
3696 const action_id wanted_action,
3697 const struct player *actor_plr,
3698 const struct unit *target_unit)
3699{
3700 if (actor_plr == nullptr || target_unit == nullptr) {
3701 /* Can't do an action when actor or target are missing. */
3702 return FALSE;
3703 }
3704
3705 ASSERT_PLAYER_ACTION(ATK_UNIT);
3706
3707 return is_action_enabled(nmap, wanted_action,
3708 &(const struct req_context) {
3709 .player = actor_plr,
3710 },
3711 &(const struct req_context) {
3712 .player = unit_owner(target_unit),
3713 .city = tile_city(unit_tile(target_unit)),
3714 .tile = unit_tile(target_unit),
3715 .unit = target_unit,
3716 .unittype = unit_type_get(target_unit),
3717 },
3718 nullptr, nullptr);
3719}
3720
3721/**********************************************************************/
3725bool is_action_enabled_city(const struct civ_map *nmap,
3726 const action_id wanted_action,
3727 const struct city *actor_city)
3728{
3729 return is_action_enabled(nmap, wanted_action,
3730 &(const struct req_context) {
3731 .player = city_owner(actor_city),
3732 .city = actor_city,
3733 .tile = city_tile(actor_city)
3734 },
3735 nullptr, nullptr, nullptr);
3736}
3737
3738/**********************************************************************/
3756static enum fc_tristate
3757action_enabled_local(const action_id wanted_action,
3758 const struct req_context *actor,
3759 const struct req_context *target)
3760{
3761 enum fc_tristate current;
3762 enum fc_tristate result;
3763
3764 if (actor == nullptr || actor->player == nullptr) {
3765 /* Need actor->player for point of view */
3766 return TRI_MAYBE;
3767 }
3768
3769 if (target == nullptr) {
3770 target = req_context_empty();
3771 }
3772
3773 result = TRI_NO;
3774 action_enabler_list_iterate(action_enablers_for_action(wanted_action),
3775 enabler) {
3776 current = fc_tristate_and(mke_eval_reqs(actor->player,
3777 actor, target,
3778 &enabler->actor_reqs,
3779 RPT_CERTAIN),
3780 mke_eval_reqs(actor->player,
3781 target, actor,
3782 &enabler->target_reqs,
3783 RPT_CERTAIN));
3784 if (current == TRI_YES) {
3785 return TRI_YES;
3786 } else if (current == TRI_MAYBE) {
3787 result = TRI_MAYBE;
3788 }
3789 } action_enabler_list_iterate_end;
3790
3791 return result;
3792}
3793
3794/**********************************************************************/
3804static bool is_effect_val_known(enum effect_type effect_type,
3805 const struct player *pov_player,
3806 const struct req_context *context,
3807 const struct req_context *other_context)
3808{
3809 effect_list_iterate(get_effects(effect_type), peffect) {
3810 if (TRI_MAYBE == mke_eval_reqs(pov_player, context, other_context,
3811 &(peffect->reqs), RPT_CERTAIN)) {
3812 return FALSE;
3813 }
3814 } effect_list_iterate_end;
3815
3816 return TRUE;
3817}
3818
3819/**********************************************************************/
3822static enum fc_tristate
3850
3851/**********************************************************************/
3859static struct act_prob ap_dipl_battle_win(const struct unit *pattacker,
3860 const struct unit *pdefender)
3861{
3862 /* Keep unconverted until the end to avoid scaling each step */
3863 int chance;
3864 struct act_prob out;
3865
3866 /* Superspy always win */
3867 if (unit_has_type_flag(pdefender, UTYF_SUPERSPY)) {
3868 /* A defending UTYF_SUPERSPY will defeat every possible attacker. */
3869 return ACTPROB_IMPOSSIBLE;
3870 }
3871 if (unit_has_type_flag(pattacker, UTYF_SUPERSPY)) {
3872 /* An attacking UTYF_SUPERSPY will defeat every possible defender
3873 * except another UTYF_SUPERSPY. */
3874 return ACTPROB_CERTAIN;
3875 }
3876
3877 /* Base chance is 50% */
3878 chance = 50;
3879
3880 /* Spy attack bonus */
3881 if (unit_has_type_flag(pattacker, UTYF_SPY)) {
3882 chance += 25;
3883 }
3884
3885 /* Spy defense bonus */
3886 if (unit_has_type_flag(pdefender, UTYF_SPY)) {
3887 chance -= 25;
3888 }
3889
3890 /* Veteran attack and defense bonus */
3891 {
3892 const struct veteran_level *vatt
3893 = utype_veteran_level(unit_type_get(pattacker), pattacker->veteran);
3894 const struct veteran_level *vdef
3895 = utype_veteran_level(unit_type_get(pdefender), pdefender->veteran);
3896
3897 chance += vatt->power_fact - vdef->power_fact;
3898 }
3899
3900 /* Defense bonus. */
3901 {
3902 const struct req_context defender_ctxt = {
3903 .player = tile_owner(pdefender->tile),
3904 .city = tile_city(pdefender->tile),
3905 .tile = pdefender->tile,
3906 };
3907 if (!is_effect_val_known(EFT_SPY_RESISTANT, unit_owner(pattacker),
3908 &defender_ctxt,
3909 nullptr)) {
3910 return ACTPROB_NOT_KNOWN;
3911 }
3912
3913 /* Reduce the chance of an attack by EFT_SPY_RESISTANT percent. */
3914 chance -= chance * get_target_bonus_effects(
3915 nullptr,
3916 &defender_ctxt,
3917 nullptr,
3918 EFT_SPY_RESISTANT
3919 ) / 100;
3920 }
3921
3922 chance = CLIP(0, chance, 100);
3923
3924 /* Convert to action probability */
3925 out.min = chance * ACTPROB_VAL_1_PCT;
3926 out.max = chance * ACTPROB_VAL_1_PCT;
3927
3928 return out;
3929}
3930
3931/**********************************************************************/
3936static struct act_prob ap_diplomat_battle(const struct unit *pattacker,
3937 const struct unit *pvictim,
3938 const struct tile *tgt_tile,
3939 const struct action *paction)
3940{
3941 struct unit *pdefender;
3942
3943 if (!can_player_see_hypotetic_units_at(unit_owner(pattacker),
3944 tgt_tile)) {
3945 /* Don't leak information about unseen defenders. */
3946 return ACTPROB_NOT_KNOWN;
3947 }
3948
3949 pdefender = get_diplomatic_defender(pattacker, pvictim, tgt_tile,
3950 paction);
3951
3952 if (pdefender) {
3953 /* There will be a diplomatic battle instead of an action. */
3954 return ap_dipl_battle_win(pattacker, pdefender);
3955 };
3956
3957 /* No diplomatic battle will occur. */
3958 return ACTPROB_CERTAIN;
3959}
3960
3961/**********************************************************************/
3964static struct act_prob act_prob_unseen_target(const struct civ_map *nmap,
3965 action_id act_id,
3966 const struct unit *actor_unit)
3967{
3968 if (action_maybe_possible_actor_unit(nmap, act_id, actor_unit)) {
3969 /* Unknown because the target is unseen. */
3970 return ACTPROB_NOT_KNOWN;
3971 } else {
3972 /* The actor it self can't do this. */
3973 return ACTPROB_IMPOSSIBLE;
3974 }
3975}
3976
3977/**********************************************************************/
3981static struct act_prob
3982action_prob_pre_action_dice_roll(const struct player *act_player,
3983 const struct unit *act_unit,
3984 const struct city *tgt_city,
3985 const struct player *tgt_player,
3986 const struct action *paction)
3987{
3988 if (is_effect_val_known(EFT_ACTION_ODDS_PCT, act_player,
3989 &(const struct req_context) {
3990 .player = act_player,
3991 .city = tgt_city,
3992 .unit = act_unit,
3993 .unittype = unit_type_get(act_unit),
3994 },
3995 &(const struct req_context) {
3996 .player = tgt_player,
3997 })
3998 && is_effect_val_known(EFT_ACTION_RESIST_PCT, act_player,
3999 &(const struct req_context) {
4000 .player = tgt_player,
4001 .city = tgt_city,
4002 .unit = act_unit,
4003 },
4004 &(const struct req_context) {
4005 .player = act_player,
4006 })) {
4007 int unconverted = action_dice_roll_odds(act_player, act_unit, tgt_city,
4008 tgt_player, paction);
4009 struct act_prob result = { .min = unconverted * ACTPROB_VAL_1_PCT,
4010 .max = unconverted * ACTPROB_VAL_1_PCT };
4011
4012 return result;
4013 } else {
4014 /* Could be improved to return a more exact probability in some cases.
4015 * Example: The player has enough information to know that the
4016 * probability always will be above 25% and always under 75% because
4017 * the only effect with unknown requirements that may apply adds (or
4018 * subtracts) 50% while all the requirements of the other effects that
4019 * may apply are known. */
4020 return ACTPROB_NOT_KNOWN;
4021 }
4022}
4023
4024/**********************************************************************/
4029static struct act_prob
4030action_prob_battle_then_dice_roll(const struct player *act_player,
4031 const struct unit *act_unit,
4032 const struct city *tgt_city,
4033 const struct unit *tgt_unit,
4034 const struct tile *tgt_tile,
4035 const struct player *tgt_player,
4036 const struct action *paction)
4037{
4038 struct act_prob battle;
4039 struct act_prob dice_roll;
4040
4041 battle = ACTPROB_CERTAIN;
4042 switch (actres_get_battle_kind(paction->result)) {
4043 case ABK_NONE:
4044 /* No pre action battle. */
4045 break;
4046 case ABK_DIPLOMATIC:
4047 battle = ap_diplomat_battle(act_unit, tgt_unit, tgt_tile,
4048 paction);
4049 break;
4050 case ABK_STANDARD:
4051 /* Not supported here yet. Implement when users appear. */
4052 fc_assert(actres_get_battle_kind(paction->result) != ABK_STANDARD);
4053 break;
4054 case ABK_COUNT:
4055 fc_assert(actres_get_battle_kind(paction->result) != ABK_COUNT);
4056 break;
4057 }
4058
4059 dice_roll = action_prob_pre_action_dice_roll(act_player, act_unit,
4060 tgt_city, tgt_player,
4061 paction);
4062
4063 return action_prob_and(&battle, &dice_roll);
4064}
4065
4066/**********************************************************************/
4077static struct act_prob
4078action_prob(const struct civ_map *nmap,
4079 const action_id wanted_action,
4080 const struct req_context *actor,
4081 const struct city *actor_home,
4082 const struct req_context *target,
4083 const struct extra_type *target_extra)
4084{
4085 enum fc_tristate known;
4086 struct act_prob chance;
4087 const struct action *paction = action_by_number(wanted_action);
4088
4089 if (actor == nullptr) {
4090 actor = req_context_empty();
4091 }
4092 if (target == nullptr) {
4093 target = req_context_empty();
4094 }
4095
4096 known = is_action_possible(nmap, wanted_action, actor, target,
4097 target_extra,
4098 FALSE, actor_home);
4099
4100 if (known == TRI_NO) {
4101 /* The action enablers are irrelevant since the action it self is
4102 * impossible. */
4103 return ACTPROB_IMPOSSIBLE;
4104 }
4105
4106 chance = ACTPROB_NOT_IMPLEMENTED;
4107
4108 known = fc_tristate_and(known,
4109 action_enabled_local(wanted_action,
4110 actor, target));
4111
4112 switch (paction->result) {
4113 case ACTRES_SPY_POISON:
4114 /* All uncertainty comes from potential diplomatic battles and the
4115 * (diplchance server setting and the) Action_Odds_Pct effect controlled
4116 * dice roll before the action. */
4117 chance = action_prob_battle_then_dice_roll(actor->player, actor->unit,
4118 target->city, target->unit,
4119 target->tile, target->player,
4120 paction);
4121 break;
4122 case ACTRES_SPY_STEAL_GOLD:
4123 /* TODO */
4124 break;
4125 case ACTRES_SPY_SPREAD_PLAGUE:
4126 /* TODO */
4127 break;
4128 case ACTRES_STEAL_MAPS:
4129 /* TODO */
4130 break;
4131 case ACTRES_SPY_SABOTAGE_UNIT:
4132 /* All uncertainty comes from potential diplomatic battles. */
4133 chance = ap_diplomat_battle(actor->unit, target->unit, target->tile,
4134 paction);
4135 break;
4136 case ACTRES_SPY_BRIBE_UNIT:
4137 case ACTRES_SPY_BRIBE_STACK:
4138 /* All uncertainty comes from potential diplomatic battles. */
4139 chance = ap_diplomat_battle(actor->unit, target->unit, target->tile,
4140 paction);
4141 break;
4142 case ACTRES_SPY_ATTACK:
4143 /* All uncertainty comes from potential diplomatic battles. */
4144 chance = ap_diplomat_battle(actor->unit, nullptr, target->tile,
4145 paction);
4146 break;
4147 case ACTRES_SPY_SABOTAGE_CITY:
4148 /* TODO */
4149 break;
4150 case ACTRES_SPY_TARGETED_SABOTAGE_CITY:
4151 /* TODO */
4152 break;
4153 case ACTRES_SPY_SABOTAGE_CITY_PRODUCTION:
4154 /* TODO */
4155 break;
4156 case ACTRES_SPY_INCITE_CITY:
4157 /* TODO */
4158 break;
4159 case ACTRES_ESTABLISH_EMBASSY:
4160 chance = ACTPROB_CERTAIN;
4161 break;
4162 case ACTRES_SPY_STEAL_TECH:
4163 /* Do the victim have anything worth taking? */
4164 known = fc_tristate_and(known,
4165 tech_can_be_stolen(actor->player,
4166 target->player));
4167
4168 /* TODO: Calculate actual chance */
4169
4170 break;
4171 case ACTRES_SPY_TARGETED_STEAL_TECH:
4172 /* Do the victim have anything worth taking? */
4173 known = fc_tristate_and(known,
4174 tech_can_be_stolen(actor->player,
4175 target->player));
4176
4177 /* TODO: Calculate actual chance */
4178
4179 break;
4180 case ACTRES_SPY_INVESTIGATE_CITY:
4181 /* There is no risk that the city won't get investigated. */
4182 chance = ACTPROB_CERTAIN;
4183 break;
4184 case ACTRES_SPY_ESCAPE:
4185 /* TODO */
4186 break;
4187 case ACTRES_TRADE_ROUTE:
4188 /* TODO */
4189 break;
4190 case ACTRES_MARKETPLACE:
4191 /* Possible when not blocked by is_action_possible() */
4192 chance = ACTPROB_CERTAIN;
4193 break;
4194 case ACTRES_HELP_WONDER:
4195 /* Possible when not blocked by is_action_possible() */
4196 chance = ACTPROB_CERTAIN;
4197 break;
4198 case ACTRES_CAPTURE_UNITS:
4199 /* No battle is fought first. */
4200 chance = ACTPROB_CERTAIN;
4201 break;
4202 case ACTRES_EXPEL_UNIT:
4203 /* No battle is fought first. */
4204 chance = ACTPROB_CERTAIN;
4205 break;
4206 case ACTRES_BOMBARD:
4207 /* No battle is fought first. */
4208 chance = ACTPROB_CERTAIN;
4209 break;
4210 case ACTRES_FOUND_CITY:
4211 /* Possible when not blocked by is_action_possible() */
4212 chance = ACTPROB_CERTAIN;
4213 break;
4214 case ACTRES_JOIN_CITY:
4215 /* Possible when not blocked by is_action_possible() */
4216 chance = ACTPROB_CERTAIN;
4217 break;
4218 case ACTRES_SPY_NUKE:
4219 /* All uncertainty comes from potential diplomatic battles and the
4220 * (diplchance server setting and the) Action_Odds_Pct effect controlled
4221 * dice roll before the action. */
4222 chance = action_prob_battle_then_dice_roll(actor->player, actor->unit,
4223 target->city, target->unit,
4224 target->tile,
4225 target->player,
4226 paction);
4227 break;
4228 case ACTRES_NUKE:
4229 /* TODO */
4230 break;
4231 case ACTRES_NUKE_UNITS:
4232 /* TODO */
4233 break;
4234 case ACTRES_DESTROY_CITY:
4235 /* No battle is fought first. */
4236 chance = ACTPROB_CERTAIN;
4237 break;
4238 case ACTRES_DISBAND_UNIT_RECOVER:
4239 /* No battle is fought first. */
4240 chance = ACTPROB_CERTAIN;
4241 break;
4242 case ACTRES_DISBAND_UNIT:
4243 /* No battle is fought first. */
4244 chance = ACTPROB_CERTAIN;
4245 break;
4246 case ACTRES_HOME_CITY:
4247 /* No battle is fought first. */
4248 chance = ACTPROB_CERTAIN;
4249 break;
4250 case ACTRES_HOMELESS:
4251 /* No battle is fought first. */
4252 chance = ACTPROB_CERTAIN;
4253 break;
4254 case ACTRES_UPGRADE_UNIT:
4255 /* No battle is fought first. */
4256 chance = ACTPROB_CERTAIN;
4257 break;
4258 case ACTRES_PARADROP:
4259 case ACTRES_PARADROP_CONQUER:
4260 /* TODO */
4261 break;
4262 case ACTRES_AIRLIFT:
4263 /* Possible when not blocked by is_action_possible() */
4264 chance = ACTPROB_CERTAIN;
4265 break;
4266 case ACTRES_ATTACK:
4267 case ACTRES_COLLECT_RANSOM:
4268 {
4269 struct unit *defender_unit = get_defender(nmap, actor->unit,
4270 target->tile, paction);
4271
4272 if (can_player_see_unit(actor->player, defender_unit)) {
4273 double unconverted = unit_win_chance(nmap, actor->unit,
4274 defender_unit, paction);
4275
4276 chance.min = MAX(ACTPROB_VAL_MIN,
4277 floor((double)ACTPROB_VAL_MAX * unconverted));
4278 chance.max = MIN(ACTPROB_VAL_MAX,
4279 ceil((double)ACTPROB_VAL_MAX * unconverted));
4280 } else if (known == TRI_YES) {
4281 known = TRI_MAYBE;
4282 }
4283 }
4284 break;
4285 case ACTRES_WIPE_UNITS:
4286 chance = ACTPROB_CERTAIN;
4287 break;
4288 case ACTRES_STRIKE_BUILDING:
4289 /* TODO: not implemented yet because:
4290 * - dice roll 100% * Action_Odds_Pct could be handled with
4291 * action_prob_pre_action_dice_roll().
4292 * - sub target building may be missing. May be missing without player
4293 * knowledge if it isn't visible. See is_improvement_visible() and
4294 * can_player_see_city_internals(). */
4295 break;
4296 case ACTRES_STRIKE_PRODUCTION:
4297 /* All uncertainty comes from the (diplchance server setting and the)
4298 * Action_Odds_Pct effect controlled dice roll before the action. */
4299 chance = action_prob_pre_action_dice_roll(actor->player, actor->unit,
4300 target->city, target->player,
4301 paction);
4302 break;
4303 case ACTRES_CONQUER_CITY:
4304 /* No battle is fought first. */
4305 chance = ACTPROB_CERTAIN;
4306 break;
4307 case ACTRES_CONQUER_EXTRAS:
4308 /* No battle is fought first. */
4309 chance = ACTPROB_CERTAIN;
4310 break;
4311 case ACTRES_HEAL_UNIT:
4312 /* No battle is fought first. */
4313 chance = ACTPROB_CERTAIN;
4314 break;
4315 case ACTRES_TRANSFORM_TERRAIN:
4316 case ACTRES_CULTIVATE:
4317 case ACTRES_PLANT:
4318 case ACTRES_PILLAGE:
4319 case ACTRES_CLEAN:
4320 case ACTRES_FORTIFY:
4321 case ACTRES_ROAD:
4322 case ACTRES_CONVERT:
4323 case ACTRES_BASE:
4324 case ACTRES_MINE:
4325 case ACTRES_IRRIGATE:
4326 chance = ACTPROB_CERTAIN;
4327 break;
4328 case ACTRES_TRANSPORT_DEBOARD:
4329 chance = ACTPROB_CERTAIN;
4330 break;
4331 case ACTRES_TRANSPORT_BOARD:
4332 chance = ACTPROB_CERTAIN;
4333 break;
4334 case ACTRES_TRANSPORT_EMBARK:
4335 chance = ACTPROB_CERTAIN;
4336 break;
4337 case ACTRES_TRANSPORT_UNLOAD:
4338 chance = ACTPROB_CERTAIN;
4339 break;
4340 case ACTRES_TRANSPORT_LOAD:
4341 chance = ACTPROB_CERTAIN;
4342 break;
4343 case ACTRES_TRANSPORT_DISEMBARK:
4344 chance = ACTPROB_CERTAIN;
4345 break;
4346 case ACTRES_HUT_ENTER:
4347 case ACTRES_HUT_FRIGHTEN:
4348 /* Entering the hut happens with a probability of 100%. What happens
4349 * next is probably up to dice rolls in Lua. */
4350 chance = ACTPROB_NOT_IMPLEMENTED;
4351 break;
4352 case ACTRES_UNIT_MOVE:
4353 case ACTRES_TELEPORT:
4354 case ACTRES_TELEPORT_CONQUER:
4355 chance = ACTPROB_CERTAIN;
4356 break;
4357 case ACTRES_SCOUT:
4358 chance = ACTPROB_CERTAIN;
4359 break;
4360 /* Not UI action, so chance is meaningless */
4361 case ACTRES_ENABLER_CHECK:
4362 chance = ACTPROB_CERTAIN;
4363 break;
4364 case ACTRES_NONE:
4365 /* Accommodate ruleset authors that wishes to roll the dice in Lua.
4366 * Would be ACTPROB_CERTAIN if not for that. */
4367 /* TODO: maybe allow the ruleset author to give a probability from
4368 * Lua? */
4369 chance = ACTPROB_NOT_IMPLEMENTED;
4370 break;
4371 }
4372
4373 /* Non signal action probabilities should be in range. */
4374 fc_assert_action((action_prob_is_signal(chance)
4375 || chance.max <= ACTPROB_VAL_MAX),
4376 chance.max = ACTPROB_VAL_MAX);
4377 fc_assert_action((action_prob_is_signal(chance)
4378 || chance.min >= ACTPROB_VAL_MIN),
4379 chance.min = ACTPROB_VAL_MIN);
4380
4381 switch (known) {
4382 case TRI_NO:
4383 return ACTPROB_IMPOSSIBLE;
4384 break;
4385 case TRI_MAYBE:
4386 return ACTPROB_NOT_KNOWN;
4387 break;
4388 case TRI_YES:
4389 return chance;
4390 break;
4391 };
4392
4393 fc_assert_msg(FALSE, "Should be yes, maybe or no");
4394
4395 return ACTPROB_NOT_IMPLEMENTED;
4396}
4397
4398/**********************************************************************/
4402static struct act_prob
4403action_prob_vs_city_full(const struct civ_map *nmap,
4404 const struct unit *actor_unit,
4405 const struct city *actor_home,
4406 const struct tile *actor_tile,
4407 const action_id act_id,
4408 const struct city *target_city)
4409{
4410 const struct impr_type *target_building;
4411 const struct unit_type *target_utype;
4412 const struct action *act = action_by_number(act_id);
4413
4414 if (actor_unit == nullptr || target_city == nullptr) {
4415 /* Can't do an action when actor or target are missing. */
4416 return ACTPROB_IMPOSSIBLE;
4417 }
4418
4419 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4420 ACTPROB_IMPOSSIBLE,
4421 "Action %s is performed by %s not %s",
4422 action_id_rule_name(act_id),
4423 action_actor_kind_name(
4424 action_id_get_actor_kind(act_id)),
4425 action_actor_kind_name(AAK_UNIT));
4426
4427 fc_assert_ret_val_msg(ATK_CITY == action_id_get_target_kind(act_id),
4428 ACTPROB_IMPOSSIBLE,
4429 "Action %s is against %s not %s",
4430 action_id_rule_name(act_id),
4431 action_target_kind_name(
4432 action_id_get_target_kind(act_id)),
4433 action_target_kind_name(ATK_CITY));
4434
4435 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4436
4437 if (!unit_can_do_action(actor_unit, act_id)) {
4438 /* No point in continuing. */
4439 return ACTPROB_IMPOSSIBLE;
4440 }
4441
4442 /* Doesn't leak information about city position since an unknown city
4443 * can't be targeted and a city can't move. */
4444 if (!action_id_distance_accepted(act_id,
4445 real_map_distance(actor_tile,
4446 city_tile(target_city)))) {
4447 /* No point in continuing. */
4448 return ACTPROB_IMPOSSIBLE;
4449 }
4450
4451 /* Doesn't leak information since it must be 100% certain from the
4452 * player's perspective that the blocking action is legal. */
4453 if (action_is_blocked_by(nmap, act, actor_unit,
4454 city_tile(target_city), target_city, nullptr)) {
4455 /* Don't offer to perform an action known to be blocked. */
4456 return ACTPROB_IMPOSSIBLE;
4457 }
4458
4459 if (!player_can_see_city_externals(unit_owner(actor_unit), target_city)) {
4460 /* The invisible city at this tile may, as far as the player knows, not
4461 * exist anymore. */
4462 return act_prob_unseen_target(nmap, act_id, actor_unit);
4463 }
4464
4465 target_building = tgt_city_local_building(target_city);
4466 target_utype = tgt_city_local_utype(target_city);
4467
4468 return action_prob(nmap, act_id,
4469 &(const struct req_context) {
4470 .player = unit_owner(actor_unit),
4471 .city = tile_city(actor_tile),
4472 .tile = actor_tile,
4473 .unit = actor_unit,
4474 .unittype = unit_type_get(actor_unit),
4475 },
4476 actor_home,
4477 &(const struct req_context) {
4478 .player = city_owner(target_city),
4479 .city = target_city,
4480 .building = target_building,
4481 .tile = city_tile(target_city),
4482 .unittype = target_utype,
4483 }, nullptr);
4484}
4485
4486/**********************************************************************/
4490struct act_prob action_prob_vs_city(const struct civ_map *nmap,
4491 const struct unit *actor_unit,
4492 const action_id act_id,
4493 const struct city *target_city)
4494{
4495 return action_prob_vs_city_full(nmap, actor_unit,
4496 unit_home(actor_unit),
4497 unit_tile(actor_unit),
4498 act_id, target_city);
4499}
4500
4501/**********************************************************************/
4505static struct act_prob
4506action_prob_vs_unit_full(const struct civ_map *nmap,
4507 const struct unit *actor_unit,
4508 const struct city *actor_home,
4509 const struct tile *actor_tile,
4510 const action_id act_id,
4511 const struct unit *target_unit)
4512{
4513 if (actor_unit == nullptr || target_unit == nullptr) {
4514 /* Can't do an action when actor or target are missing. */
4515 return ACTPROB_IMPOSSIBLE;
4516 }
4517
4518 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4519 ACTPROB_IMPOSSIBLE,
4520 "Action %s is performed by %s not %s",
4521 action_id_rule_name(act_id),
4522 action_actor_kind_name(
4523 action_id_get_actor_kind(act_id)),
4524 action_actor_kind_name(AAK_UNIT));
4525
4526 fc_assert_ret_val_msg(ATK_UNIT == action_id_get_target_kind(act_id),
4527 ACTPROB_IMPOSSIBLE,
4528 "Action %s is against %s not %s",
4529 action_id_rule_name(act_id),
4530 action_target_kind_name(
4531 action_id_get_target_kind(act_id)),
4532 action_target_kind_name(ATK_UNIT));
4533
4534 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4535
4536 if (!unit_can_do_action(actor_unit, act_id)) {
4537 /* No point in continuing. */
4538 return ACTPROB_IMPOSSIBLE;
4539 }
4540
4541 /* Doesn't leak information about unit position since an unseen unit can't
4542 * be targeted. */
4543 if (!action_id_distance_accepted(act_id,
4544 real_map_distance(actor_tile,
4545 unit_tile(target_unit)))) {
4546 /* No point in continuing. */
4547 return ACTPROB_IMPOSSIBLE;
4548 }
4549
4550 return action_prob(nmap, act_id,
4551 &(const struct req_context) {
4552 .player = unit_owner(actor_unit),
4553 .city = tile_city(actor_tile),
4554 .tile = actor_tile,
4555 .unit = actor_unit,
4556 .unittype = unit_type_get(actor_unit),
4557 },
4558 actor_home,
4559 &(const struct req_context) {
4560 .player = unit_owner(target_unit),
4561 .city = tile_city(unit_tile(target_unit)),
4562 .tile = unit_tile(target_unit),
4563 .unit = target_unit,
4564 .unittype = unit_type_get(target_unit),
4565 },
4566 nullptr);
4567}
4568
4569/**********************************************************************/
4573struct act_prob action_prob_vs_unit(const struct civ_map *nmap,
4574 const struct unit *actor_unit,
4575 const action_id act_id,
4576 const struct unit *target_unit)
4577{
4578 return action_prob_vs_unit_full(nmap, actor_unit,
4579 unit_home(actor_unit),
4580 unit_tile(actor_unit),
4581 act_id,
4582 target_unit);
4583}
4584
4585/**********************************************************************/
4589static struct act_prob
4590action_prob_vs_stack_full(const struct civ_map *nmap,
4591 const struct unit *actor_unit,
4592 const struct city *actor_home,
4593 const struct tile *actor_tile,
4594 const action_id act_id,
4595 const struct tile *target_tile)
4596{
4597 struct act_prob prob_all;
4598 const struct req_context *actor_ctxt;
4599 const struct action *act = action_by_number(act_id);
4600
4601 if (actor_unit == nullptr || target_tile == nullptr) {
4602 /* Can't do an action when actor or target are missing. */
4603 return ACTPROB_IMPOSSIBLE;
4604 }
4605
4606 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4607 ACTPROB_IMPOSSIBLE,
4608 "Action %s is performed by %s not %s",
4609 action_id_rule_name(act_id),
4610 action_actor_kind_name(
4611 action_id_get_actor_kind(act_id)),
4612 action_actor_kind_name(AAK_UNIT));
4613
4614 fc_assert_ret_val_msg(ATK_STACK == action_id_get_target_kind(act_id),
4615 ACTPROB_IMPOSSIBLE,
4616 "Action %s is against %s not %s",
4617 action_id_rule_name(act_id),
4618 action_target_kind_name(
4619 action_id_get_target_kind(act_id)),
4620 action_target_kind_name(ATK_STACK));
4621
4622 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4623
4624 if (!unit_can_do_action(actor_unit, act_id)) {
4625 /* No point in continuing. */
4626 return ACTPROB_IMPOSSIBLE;
4627 }
4628
4629 /* Doesn't leak information about unit stack position since it is
4630 * specified as a tile and an unknown tile's position is known. */
4631 if (!action_id_distance_accepted(act_id,
4632 real_map_distance(actor_tile,
4633 target_tile))) {
4634 /* No point in continuing. */
4635 return ACTPROB_IMPOSSIBLE;
4636 }
4637
4638 /* Doesn't leak information since the actor player can see the target
4639 * tile. */
4640 if (tile_is_seen(target_tile, unit_owner(actor_unit))
4641 && tile_city(target_tile) != nullptr
4642 && !utype_can_do_act_if_tgt_citytile(unit_type_get(actor_unit),
4643 act_id,
4644 CITYT_CENTER, TRUE)) {
4645 /* Don't offer to perform actions that never can target a unit stack in
4646 * a city. */
4647 return ACTPROB_IMPOSSIBLE;
4648 }
4649
4650 /* Doesn't leak information since it must be 100% certain from the
4651 * player's perspective that the blocking action is legal. */
4652 unit_list_iterate(target_tile->units, target_unit) {
4653 if (action_is_blocked_by(nmap, act, actor_unit,
4654 target_tile, tile_city(target_tile),
4655 target_unit)) {
4656 /* Don't offer to perform an action known to be blocked. */
4657 return ACTPROB_IMPOSSIBLE;
4658 }
4659 } unit_list_iterate_end;
4660
4661 /* Must be done here since an empty unseen tile will result in
4662 * ACTPROB_IMPOSSIBLE. */
4663 if (unit_list_size(target_tile->units) == 0) {
4664 /* Can't act against an empty tile. */
4665
4666 if (player_can_trust_tile_has_no_units(unit_owner(actor_unit),
4667 target_tile)) {
4668 /* Known empty tile. */
4669 return ACTPROB_IMPOSSIBLE;
4670 } else {
4671 /* The player doesn't know that the tile is empty. */
4672 return act_prob_unseen_target(nmap, act_id, actor_unit);
4673 }
4674 }
4675
4676 if ((action_id_has_result_safe(act_id, ACTRES_ATTACK)
4677 || action_id_has_result_safe(act_id, ACTRES_WIPE_UNITS)
4678 || action_id_has_result_safe(act_id, ACTRES_COLLECT_RANSOM))
4679 && tile_city(target_tile) != nullptr
4680 && !pplayers_at_war(city_owner(tile_city(target_tile)),
4681 unit_owner(actor_unit))) {
4682 /* Hard coded rule: can't "Bombard", "Suicide Attack", or "Attack"
4683 * units in non enemy cities. */
4684 return ACTPROB_IMPOSSIBLE;
4685 }
4686
4687 if ((action_id_has_result_safe(act_id, ACTRES_ATTACK)
4688 || action_id_has_result_safe(act_id, ACTRES_WIPE_UNITS)
4689 || action_id_has_result_safe(act_id, ACTRES_NUKE_UNITS)
4690 || action_id_has_result_safe(act_id, ACTRES_COLLECT_RANSOM))
4691 && !is_native_tile(unit_type_get(actor_unit), target_tile)
4692 && !can_attack_non_native(unit_type_get(actor_unit))) {
4693 /* Hard coded rule: can't "Nuke Units", "Wipe Units", "Suicide Attack",
4694 * or "Attack" units on non native tile without "AttackNonNative" and
4695 * not "Only_Native_Attack". */
4696 return ACTPROB_IMPOSSIBLE;
4697 }
4698
4699 /* Invisible units at this tile can make the action legal or illegal.
4700 * Invisible units can be stacked with visible units. The possible
4701 * existence of invisible units therefore makes the result uncertain. */
4702 prob_all = (can_player_see_hypotetic_units_at(unit_owner(actor_unit),
4703 target_tile)
4704 ? ACTPROB_CERTAIN : ACTPROB_NOT_KNOWN);
4705
4706 actor_ctxt = &(const struct req_context) {
4707 .player = unit_owner(actor_unit),
4708 .city = tile_city(actor_tile),
4709 .tile = actor_tile,
4710 .unit = actor_unit,
4711 .unittype = unit_type_get(actor_unit),
4712 };
4713
4714 unit_list_iterate(target_tile->units, target_unit) {
4715 struct act_prob prob_unit;
4716
4717 if (!can_player_see_unit(unit_owner(actor_unit), target_unit)) {
4718 /* Only visible units are considered. The invisible units contributed
4719 * their uncertainty to prob_all above. */
4720 continue;
4721 }
4722
4723 prob_unit = action_prob(nmap, act_id, actor_ctxt, actor_home,
4724 &(const struct req_context) {
4725 .player = unit_owner(target_unit),
4726 .city = tile_city(unit_tile(target_unit)),
4727 .tile = unit_tile(target_unit),
4728 .unit = target_unit,
4729 .unittype = unit_type_get(target_unit),
4730 },
4731 nullptr);
4732
4733 if (!action_prob_possible(prob_unit)) {
4734 /* One unit makes it impossible for all units. */
4735 return ACTPROB_IMPOSSIBLE;
4736 } else if (action_prob_not_impl(prob_unit)) {
4737 /* Not implemented dominates all except impossible. */
4738 prob_all = ACTPROB_NOT_IMPLEMENTED;
4739 } else {
4740 fc_assert_msg(!action_prob_is_signal(prob_unit),
4741 "Invalid probability [%d, %d]",
4742 prob_unit.min, prob_unit.max);
4743
4744 if (action_prob_is_signal(prob_all)) {
4745 /* Special values dominate regular values. */
4746 continue;
4747 }
4748
4749 /* Probability against all target units considered until this moment
4750 * and the probability against this target unit. */
4751 prob_all.min = (prob_all.min * prob_unit.min) / ACTPROB_VAL_MAX;
4752 prob_all.max = (prob_all.max * prob_unit.max) / ACTPROB_VAL_MAX;
4753 break;
4754 }
4755 } unit_list_iterate_end;
4756
4757 /* Not impossible for any of the units at the tile. */
4758 return prob_all;
4759}
4760
4761/**********************************************************************/
4765struct act_prob action_prob_vs_stack(const struct civ_map *nmap,
4766 const struct unit *actor_unit,
4767 const action_id act_id,
4768 const struct tile *target_tile)
4769{
4770 return action_prob_vs_stack_full(nmap, actor_unit,
4771 unit_home(actor_unit),
4772 unit_tile(actor_unit),
4773 act_id,
4774 target_tile);
4775}
4776
4777/**********************************************************************/
4781static struct act_prob
4782action_prob_vs_tile_full(const struct civ_map *nmap,
4783 const struct unit *actor_unit,
4784 const struct city *actor_home,
4785 const struct tile *actor_tile,
4786 const action_id act_id,
4787 const struct tile *target_tile,
4788 const struct extra_type *target_extra)
4789{
4790 if (actor_unit == nullptr || target_tile == nullptr) {
4791 /* Can't do an action when actor or target are missing. */
4792 return ACTPROB_IMPOSSIBLE;
4793 }
4794
4795 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4796 ACTPROB_IMPOSSIBLE,
4797 "Action %s is performed by %s not %s",
4798 action_id_rule_name(act_id),
4799 action_actor_kind_name(
4800 action_id_get_actor_kind(act_id)),
4801 action_actor_kind_name(AAK_UNIT));
4802
4803 fc_assert_ret_val_msg(ATK_TILE == action_id_get_target_kind(act_id),
4804 ACTPROB_IMPOSSIBLE,
4805 "Action %s is against %s not %s",
4806 action_id_rule_name(act_id),
4807 action_target_kind_name(
4808 action_id_get_target_kind(act_id)),
4809 action_target_kind_name(ATK_TILE));
4810
4811 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4812
4813 if (!unit_can_do_action(actor_unit, act_id)) {
4814 /* No point in continuing. */
4815 return ACTPROB_IMPOSSIBLE;
4816 }
4817
4818 /* Doesn't leak information about tile position since an unknown tile's
4819 * position is known. */
4820 if (!action_id_distance_accepted(act_id,
4821 real_map_distance(actor_tile,
4822 target_tile))) {
4823 /* No point in continuing. */
4824 return ACTPROB_IMPOSSIBLE;
4825 }
4826
4827 return action_prob(nmap, act_id,
4828 &(const struct req_context) {
4829 .player = unit_owner(actor_unit),
4830 .city = tile_city(actor_tile),
4831 .tile = actor_tile,
4832 .unit = actor_unit,
4833 .unittype = unit_type_get(actor_unit),
4834 },
4835 actor_home,
4836 &(const struct req_context) {
4837 .player = tile_owner(target_tile),
4838 .city = tile_city(target_tile),
4839 .tile = target_tile,
4840 },
4841 target_extra);
4842}
4843
4844/**********************************************************************/
4848struct act_prob action_prob_vs_tile(const struct civ_map *nmap,
4849 const struct unit *actor_unit,
4850 const action_id act_id,
4851 const struct tile *target_tile,
4852 const struct extra_type *target_extra)
4853{
4854 return action_prob_vs_tile_full(nmap, actor_unit,
4855 unit_home(actor_unit),
4856 unit_tile(actor_unit),
4857 act_id, target_tile, target_extra);
4858}
4859
4860/**********************************************************************/
4864static struct act_prob
4865action_prob_vs_extras_full(const struct civ_map *nmap,
4866 const struct unit *actor_unit,
4867 const struct city *actor_home,
4868 const struct tile *actor_tile,
4869 const action_id act_id,
4870 const struct tile *target_tile,
4871 const struct extra_type *target_extra)
4872{
4873 if (actor_unit == nullptr || target_tile == nullptr) {
4874 /* Can't do an action when actor or target are missing. */
4875 return ACTPROB_IMPOSSIBLE;
4876 }
4877
4878 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4879 ACTPROB_IMPOSSIBLE,
4880 "Action %s is performed by %s not %s",
4881 action_id_rule_name(act_id),
4882 action_actor_kind_name(
4883 action_id_get_actor_kind(act_id)),
4884 action_actor_kind_name(AAK_UNIT));
4885
4886 fc_assert_ret_val_msg(ATK_EXTRAS == action_id_get_target_kind(act_id),
4887 ACTPROB_IMPOSSIBLE,
4888 "Action %s is against %s not %s",
4889 action_id_rule_name(act_id),
4890 action_target_kind_name(
4891 action_id_get_target_kind(act_id)),
4892 action_target_kind_name(ATK_EXTRAS));
4893
4894 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4895
4896 if (!unit_can_do_action(actor_unit, act_id)) {
4897 /* No point in continuing. */
4898 return ACTPROB_IMPOSSIBLE;
4899 }
4900
4901 /* Doesn't leak information about tile position since an unknown tile's
4902 * position is known. */
4903 if (!action_id_distance_accepted(act_id,
4904 real_map_distance(actor_tile,
4905 target_tile))) {
4906 /* No point in continuing. */
4907 return ACTPROB_IMPOSSIBLE;
4908 }
4909
4910 return action_prob(nmap, act_id,
4911 &(const struct req_context) {
4912 .player = unit_owner(actor_unit),
4913 .city = tile_city(actor_tile),
4914 .tile = actor_tile,
4915 .unit = actor_unit,
4916 .unittype = unit_type_get(actor_unit),
4917 },
4918 actor_home,
4919 &(const struct req_context) {
4920 .player = target_tile->extras_owner,
4921 .city = tile_city(target_tile),
4922 .tile = target_tile,
4923 },
4924 target_extra);
4925}
4926
4927/**********************************************************************/
4931struct act_prob action_prob_vs_extras(const struct civ_map *nmap,
4932 const struct unit *actor_unit,
4933 const action_id act_id,
4934 const struct tile *target_tile,
4935 const struct extra_type *target_extra)
4936{
4937 return action_prob_vs_extras_full(nmap, actor_unit,
4938 unit_home(actor_unit),
4939 unit_tile(actor_unit),
4940 act_id, target_tile, target_extra);
4941}
4942
4943/**********************************************************************/
4947static struct act_prob
4948action_prob_self_full(const struct civ_map *nmap,
4949 const struct unit *actor_unit,
4950 const struct city *actor_home,
4951 const struct tile *actor_tile,
4952 const action_id act_id)
4953{
4954 if (actor_unit == nullptr) {
4955 /* Can't do the action when the actor is missing. */
4956 return ACTPROB_IMPOSSIBLE;
4957 }
4958
4959 /* No point in checking distance to target. It is always 0. */
4960
4961 fc_assert_ret_val_msg(AAK_UNIT == action_id_get_actor_kind(act_id),
4962 ACTPROB_IMPOSSIBLE,
4963 "Action %s is performed by %s not %s",
4964 action_id_rule_name(act_id),
4965 action_actor_kind_name(
4966 action_id_get_actor_kind(act_id)),
4967 action_actor_kind_name(AAK_UNIT));
4968
4969 fc_assert_ret_val_msg(ATK_SELF == action_id_get_target_kind(act_id),
4970 ACTPROB_IMPOSSIBLE,
4971 "Action %s is against %s not %s",
4972 action_id_rule_name(act_id),
4973 action_target_kind_name(
4974 action_id_get_target_kind(act_id)),
4975 action_target_kind_name(ATK_SELF));
4976
4977 fc_assert_ret_val(actor_tile, ACTPROB_IMPOSSIBLE);
4978
4979 if (!unit_can_do_action(actor_unit, act_id)) {
4980 /* No point in continuing. */
4981 return ACTPROB_IMPOSSIBLE;
4982 }
4983
4984 return action_prob(nmap, act_id,
4985 &(const struct req_context) {
4986 .player = unit_owner(actor_unit),
4987 .city = tile_city(actor_tile),
4988 .tile = actor_tile,
4989 .unit = actor_unit,
4990 .unittype = unit_type_get(actor_unit),
4991 },
4992 actor_home,
4993 nullptr,
4994 nullptr);
4995}
4996
4997/**********************************************************************/
5001struct act_prob action_prob_self(const struct civ_map *nmap,
5002 const struct unit *actor_unit,
5003 const action_id act_id)
5004{
5005 return action_prob_self_full(nmap, actor_unit,
5006 unit_home(actor_unit),
5007 unit_tile(actor_unit),
5008 act_id);
5009}
5010
5011/**********************************************************************/
5023struct act_prob action_prob_unit_vs_tgt(const struct civ_map *nmap,
5024 const struct action *paction,
5025 const struct unit *act_unit,
5026 const struct city *tgt_city,
5027 const struct unit *tgt_unit,
5028 const struct tile *tgt_tile,
5029 const struct extra_type *extra_tgt)
5030{
5031 /* Assume impossible until told otherwise. */
5032 struct act_prob prob = ACTPROB_IMPOSSIBLE;
5033
5034 fc_assert_ret_val(paction, ACTPROB_IMPOSSIBLE);
5035 fc_assert_ret_val(act_unit, ACTPROB_IMPOSSIBLE);
5036
5037 switch (action_get_target_kind(paction)) {
5038 case ATK_STACK:
5039 if (tgt_tile) {
5040 prob = action_prob_vs_stack(nmap, act_unit, paction->id, tgt_tile);
5041 }
5042 break;
5043 case ATK_TILE:
5044 if (tgt_tile) {
5045 prob = action_prob_vs_tile(nmap, act_unit, paction->id, tgt_tile, extra_tgt);
5046 }
5047 break;
5048 case ATK_EXTRAS:
5049 if (tgt_tile) {
5050 prob = action_prob_vs_extras(nmap, act_unit, paction->id,
5051 tgt_tile, extra_tgt);
5052 }
5053 break;
5054 case ATK_CITY:
5055 if (tgt_city) {
5056 prob = action_prob_vs_city(nmap, act_unit, paction->id, tgt_city);
5057 }
5058 break;
5059 case ATK_UNIT:
5060 if (tgt_unit) {
5061 prob = action_prob_vs_unit(nmap, act_unit, paction->id, tgt_unit);
5062 }
5063 break;
5064 case ATK_SELF:
5065 prob = action_prob_self(nmap, act_unit, paction->id);
5066 break;
5067 case ATK_COUNT:
5068 log_error("Invalid action target kind");
5069 break;
5070 }
5071
5072 return prob;
5073}
5074
5075/**********************************************************************/
5080struct act_prob action_speculate_unit_on_city(const struct civ_map *nmap,
5081 const action_id act_id,
5082 const struct unit *actor,
5083 const struct city *actor_home,
5084 const struct tile *actor_tile,
5085 const bool omniscient_cheat,
5086 const struct city* target)
5087{
5088 /* FIXME: some unit state requirements still depend on the actor unit's
5089 * current position rather than on actor_tile. Maybe this function should
5090 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5091 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5092
5093 if (omniscient_cheat) {
5094 if (is_action_enabled_unit_on_city_full(nmap, act_id,
5095 actor, actor_home, actor_tile,
5096 target)) {
5097 return ACTPROB_CERTAIN;
5098 } else {
5099 return ACTPROB_IMPOSSIBLE;
5100 }
5101 } else {
5102 /* FIXME: this branch result depends _directly_ on actor's position.
5103 * I.e., like, not adjacent, no action. Other branch ignores radius. */
5104 return action_prob_vs_city_full(nmap, actor, actor_home, actor_tile,
5105 act_id, target);
5106 }
5107}
5108
5109/**********************************************************************/
5114struct act_prob
5115action_speculate_unit_on_unit(const struct civ_map *nmap,
5116 action_id act_id,
5117 const struct unit *actor,
5118 const struct city *actor_home,
5119 const struct tile *actor_tile,
5120 bool omniscient_cheat,
5121 const struct unit *target)
5122{
5123 /* FIXME: some unit state requirements still depend on the actor unit's
5124 * current position rather than on actor_tile. Maybe this function should
5125 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5126 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5127
5128 if (omniscient_cheat) {
5129 if (is_action_enabled_unit_on_unit_full(nmap, act_id,
5130 actor, actor_home, actor_tile,
5131 target)) {
5132 return ACTPROB_CERTAIN;
5133 } else {
5134 return ACTPROB_IMPOSSIBLE;
5135 }
5136 } else {
5137 return action_prob_vs_unit_full(nmap, actor, actor_home, actor_tile,
5138 act_id, target);
5139 }
5140}
5141
5142/**********************************************************************/
5147struct act_prob
5148action_speculate_unit_on_stack(const struct civ_map *nmap,
5149 action_id act_id,
5150 const struct unit *actor,
5151 const struct city *actor_home,
5152 const struct tile *actor_tile,
5153 bool omniscient_cheat,
5154 const struct tile *target)
5155{
5156 /* FIXME: some unit state requirements still depend on the actor unit's
5157 * current position rather than on actor_tile. Maybe this function should
5158 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5159 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5160
5161 if (omniscient_cheat) {
5162 if (is_action_enabled_unit_on_stack_full(nmap, act_id,
5163 actor, actor_home, actor_tile,
5164 target)) {
5165 return ACTPROB_CERTAIN;
5166 } else {
5167 return ACTPROB_IMPOSSIBLE;
5168 }
5169 } else {
5170 return action_prob_vs_stack_full(nmap, actor, actor_home, actor_tile,
5171 act_id, target);
5172 }
5173}
5174
5175/**********************************************************************/
5180struct act_prob
5181action_speculate_unit_on_tile(const struct civ_map *nmap,
5182 action_id act_id,
5183 const struct unit *actor,
5184 const struct city *actor_home,
5185 const struct tile *actor_tile,
5186 bool omniscient_cheat,
5187 const struct tile *target_tile,
5188 const struct extra_type *target_extra)
5189{
5190 /* FIXME: some unit state requirements still depend on the actor unit's
5191 * current position rather than on actor_tile. Maybe this function should
5192 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5193 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5194
5195 if (omniscient_cheat) {
5196 if (is_action_enabled_unit_on_tile_full(nmap, act_id,
5197 actor, actor_home, actor_tile,
5198 target_tile, target_extra)) {
5199 return ACTPROB_CERTAIN;
5200 } else {
5201 return ACTPROB_IMPOSSIBLE;
5202 }
5203 } else {
5204 return action_prob_vs_tile_full(nmap, actor, actor_home, actor_tile,
5205 act_id, target_tile, target_extra);
5206 }
5207}
5208
5209/**********************************************************************/
5214struct act_prob
5215action_speculate_unit_on_extras(const struct civ_map *nmap,
5216 action_id act_id,
5217 const struct unit *actor,
5218 const struct city *actor_home,
5219 const struct tile *actor_tile,
5220 bool omniscient_cheat,
5221 const struct tile *target_tile,
5222 const struct extra_type *target_extra)
5223{
5224 /* FIXME: some unit state requirements still depend on the actor unit's
5225 * current position rather than on actor_tile. Maybe this function should
5226 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5227 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5228
5229 if (omniscient_cheat) {
5230 if (is_action_enabled_unit_on_extras_full(nmap, act_id,
5231 actor, actor_home, actor_tile,
5232 target_tile, target_extra)) {
5233 return ACTPROB_CERTAIN;
5234 } else {
5235 return ACTPROB_IMPOSSIBLE;
5236 }
5237 } else {
5238 return action_prob_vs_extras_full(nmap, actor, actor_home, actor_tile,
5239 act_id, target_tile, target_extra);
5240 }
5241}
5242
5243/**********************************************************************/
5248struct act_prob
5249action_speculate_unit_on_self(const struct civ_map *nmap,
5250 action_id act_id,
5251 const struct unit *actor,
5252 const struct city *actor_home,
5253 const struct tile *actor_tile,
5254 bool omniscient_cheat)
5255{
5256 /* FIXME: some unit state requirements still depend on the actor unit's
5257 * current position rather than on actor_tile. Maybe this function should
5258 * return ACTPROB_NOT_IMPLEMENTED when one of those is detected and no
5259 * other requirement makes the action ACTPROB_IMPOSSIBLE? */
5260 if (omniscient_cheat) {
5261 if (is_action_enabled_unit_on_self_full(nmap, act_id,
5262 actor, actor_home, actor_tile)) {
5263 return ACTPROB_CERTAIN;
5264 } else {
5265 return ACTPROB_IMPOSSIBLE;
5266 }
5267 } else {
5268 return action_prob_self_full(nmap, actor, actor_home, actor_tile,
5269 act_id);
5270 }
5271}
5272
5273/**********************************************************************/
5276struct act_prob action_prob_new_impossible(void)
5277{
5278 struct act_prob out = { ACTPROB_VAL_MIN, ACTPROB_VAL_MIN };
5279
5280 return out;
5281}
5282
5283/**********************************************************************/
5286struct act_prob action_prob_new_certain(void)
5287{
5288 struct act_prob out = { ACTPROB_VAL_MAX, ACTPROB_VAL_MAX };
5289
5290 return out;
5291}
5292
5293/**********************************************************************/
5296struct act_prob action_prob_new_not_relevant(void)
5297{
5298 struct act_prob out = { ACTPROB_VAL_NA, ACTPROB_VAL_MIN};
5299
5300 return out;
5301}
5302
5303/**********************************************************************/
5306struct act_prob action_prob_new_not_impl(void)
5307{
5308 struct act_prob out = { ACTPROB_VAL_NOT_IMPL, ACTPROB_VAL_MIN };
5309
5310 return out;
5311}
5312
5313/**********************************************************************/
5316struct act_prob action_prob_new_unknown(void)
5317{
5318 struct act_prob out = { ACTPROB_VAL_MIN, ACTPROB_VAL_MAX };
5319
5320 return out;
5321}
5322
5323/**********************************************************************/
5327bool action_prob_possible(const struct act_prob probability)
5328{
5329 return (ACTPROB_VAL_MIN < probability.max
5330 || action_prob_not_impl(probability));
5331}
5332
5333/**********************************************************************/
5337bool action_prob_certain(const struct act_prob probability)
5338{
5339 return (ACTPROB_VAL_MAX == probability.min
5340 && ACTPROB_VAL_MAX == probability.max);
5341}
5342
5343/**********************************************************************/
5347static inline bool
5353
5354/**********************************************************************/
5358static inline bool
5359action_prob_not_impl(const struct act_prob probability)
5360{
5361 return probability.min == ACTPROB_VAL_NOT_IMPL
5362 && probability.max == ACTPROB_VAL_MIN;
5363}
5364
5365/**********************************************************************/
5369static inline bool
5370action_prob_is_signal(const struct act_prob probability)
5371{
5372 return probability.max < probability.min;
5373}
5374
5375/**********************************************************************/
5378bool are_action_probabilitys_equal(const struct act_prob *ap1,
5379 const struct act_prob *ap2)
5380{
5381 return ap1->min == ap2->min && ap1->max == ap2->max;
5382}
5383
5384/**********************************************************************/
5387int action_prob_cmp_pessimist(const struct act_prob ap1,
5388 const struct act_prob ap2)
5389{
5390 struct act_prob my_ap1;
5391 struct act_prob my_ap2;
5392
5393 /* The action probabilities are real. */
5394 fc_assert(!action_prob_not_relevant(ap1));
5395 fc_assert(!action_prob_not_relevant(ap2));
5396
5397 /* Convert any signals to ACTPROB_NOT_KNOWN. */
5398 if (action_prob_is_signal(ap1)) {
5399 /* Assert that it is OK to convert the signal. */
5400 fc_assert(action_prob_not_impl(ap1));
5401
5402 my_ap1 = ACTPROB_NOT_KNOWN;
5403 } else {
5404 my_ap1 = ap1;
5405 }
5406
5407 if (action_prob_is_signal(ap2)) {
5408 /* Assert that it is OK to convert the signal. */
5409 fc_assert(action_prob_not_impl(ap2));
5410
5411 my_ap2 = ACTPROB_NOT_KNOWN;
5412 } else {
5413 my_ap2 = ap2;
5414 }
5415
5416 /* The action probabilities now have a comparison friendly form. */
5417 fc_assert(!action_prob_is_signal(my_ap1));
5418 fc_assert(!action_prob_is_signal(my_ap2));
5419
5420 /* Do the comparison. Start with min. Continue with max. */
5421 if (my_ap1.min < my_ap2.min) {
5422 return -1;
5423 } else if (my_ap1.min > my_ap2.min) {
5424 return 1;
5425 } else if (my_ap1.max < my_ap2.max) {
5426 return -1;
5427 } else if (my_ap1.max > my_ap2.max) {
5428 return 1;
5429 } else {
5430 return 0;
5431 }
5432}
5433
5434/**********************************************************************/
5438double action_prob_to_0_to_1_pessimist(const struct act_prob ap)
5439{
5440 struct act_prob my_ap;
5441
5442 /* The action probability is real. */
5443 fc_assert(!action_prob_not_relevant(ap));
5444
5445 /* Convert any signals to ACTPROB_NOT_KNOWN. */
5446 if (action_prob_is_signal(ap)) {
5447 /* Assert that it is OK to convert the signal. */
5448 fc_assert(action_prob_not_impl(ap));
5449
5450 my_ap = ACTPROB_NOT_KNOWN;
5451 } else {
5452 my_ap = ap;
5453 }
5454
5455 /* The action probability now has a math friendly form. */
5456 fc_assert(!action_prob_is_signal(my_ap));
5457
5458 return (double)my_ap.min / (double) ACTPROB_VAL_MAX;
5459}
5460
5461/**********************************************************************/
5465struct act_prob action_prob_and(const struct act_prob *ap1,
5466 const struct act_prob *ap2)
5467{
5468 struct act_prob my_ap1;
5469 struct act_prob my_ap2;
5470 struct act_prob out;
5471
5472 /* The action probabilities are real. */
5473 fc_assert(ap1 && !action_prob_not_relevant(*ap1));
5474 fc_assert(ap2 && !action_prob_not_relevant(*ap2));
5475
5476 if (action_prob_is_signal(*ap1)
5477 && are_action_probabilitys_equal(ap1, ap2)) {
5478 /* Keep the information rather than converting the signal to
5479 * ACTPROB_NOT_KNOWN. */
5480
5481 /* Assert that it is OK to convert the signal. */
5482 fc_assert(action_prob_not_impl(*ap1));
5483
5484 out.min = ap1->min;
5485 out.max = ap2->max;
5486
5487 return out;
5488 }
5489
5490 /* Convert any signals to ACTPROB_NOT_KNOWN. */
5491 if (action_prob_is_signal(*ap1)) {
5492 /* Assert that it is OK to convert the signal. */
5493 fc_assert(action_prob_not_impl(*ap1));
5494
5495 my_ap1.min = ACTPROB_VAL_MIN;
5496 my_ap1.max = ACTPROB_VAL_MAX;
5497 } else {
5498 my_ap1.min = ap1->min;
5499 my_ap1.max = ap1->max;
5500 }
5501
5502 if (action_prob_is_signal(*ap2)) {
5503 /* Assert that it is OK to convert the signal. */
5504 fc_assert(action_prob_not_impl(*ap2));
5505
5506 my_ap2.min = ACTPROB_VAL_MIN;
5507 my_ap2.max = ACTPROB_VAL_MAX;
5508 } else {
5509 my_ap2.min = ap2->min;
5510 my_ap2.max = ap2->max;
5511 }
5512
5513 /* The action probabilities now have a math friendly form. */
5514 fc_assert(!action_prob_is_signal(my_ap1));
5515 fc_assert(!action_prob_is_signal(my_ap2));
5516
5517 /* Do the math. */
5518 out.min = (my_ap1.min * my_ap2.min) / ACTPROB_VAL_MAX;
5519 out.max = (my_ap1.max * my_ap2.max) / ACTPROB_VAL_MAX;
5520
5521 /* Cap at 100%. */
5522 out.min = MIN(out.min, ACTPROB_VAL_MAX);
5523 out.max = MIN(out.max, ACTPROB_VAL_MAX);
5524
5525 return out;
5526}
5527
5528/**********************************************************************/
5535struct act_prob action_prob_fall_back(const struct act_prob *ap1,
5536 const struct act_prob *ap2)
5537{
5538 struct act_prob my_ap1;
5539 struct act_prob my_ap2;
5540 struct act_prob out;
5541
5542 /* The action probabilities are real. */
5543 fc_assert(ap1 && !action_prob_not_relevant(*ap1));
5544 fc_assert(ap2 && !action_prob_not_relevant(*ap2));
5545
5546 if (action_prob_is_signal(*ap1)
5547 && are_action_probabilitys_equal(ap1, ap2)) {
5548 /* Keep the information rather than converting the signal to
5549 * ACTPROB_NOT_KNOWN. */
5550
5551 /* Assert that it is OK to convert the signal. */
5552 fc_assert(action_prob_not_impl(*ap1));
5553
5554 out.min = ap1->min;
5555 out.max = ap2->max;
5556
5557 return out;
5558 }
5559
5560 /* Convert any signals to ACTPROB_NOT_KNOWN. */
5561 if (action_prob_is_signal(*ap1)) {
5562 /* Assert that it is OK to convert the signal. */
5563 fc_assert(action_prob_not_impl(*ap1));
5564
5565 my_ap1.min = ACTPROB_VAL_MIN;
5566 my_ap1.max = ACTPROB_VAL_MAX;
5567 } else {
5568 my_ap1.min = ap1->min;
5569 my_ap1.max = ap1->max;
5570 }
5571
5572 if (action_prob_is_signal(*ap2)) {
5573 /* Assert that it is OK to convert the signal. */
5574 fc_assert(action_prob_not_impl(*ap2));
5575
5576 my_ap2.min = ACTPROB_VAL_MIN;
5577 my_ap2.max = ACTPROB_VAL_MAX;
5578 } else {
5579 my_ap2.min = ap2->min;
5580 my_ap2.max = ap2->max;
5581 }
5582
5583 /* The action probabilities now have a math friendly form. */
5584 fc_assert(!action_prob_is_signal(my_ap1));
5585 fc_assert(!action_prob_is_signal(my_ap2));
5586
5587 /* Do the math. */
5588 out.min = my_ap1.min + (((ACTPROB_VAL_MAX - my_ap1.min) * my_ap2.min)
5589 / ACTPROB_VAL_MAX);
5590 out.max = my_ap1.max + (((ACTPROB_VAL_MAX - my_ap1.max) * my_ap2.max)
5591 / ACTPROB_VAL_MAX);
5592
5593 /* Cap at 100%. */
5594 out.min = MIN(out.min, ACTPROB_VAL_MAX);
5595 out.max = MIN(out.max, ACTPROB_VAL_MAX);
5596
5597 return out;
5598}
5599
5600/**********************************************************************/
5603int action_dice_roll_initial_odds(const struct action *paction)
5604{
5605 switch (actres_dice_type(paction->result)) {
5606 case DRT_DIPLCHANCE:
5607 if (BV_ISSET(game.info.diplchance_initial_odds, paction->id)) {
5608 /* Take the initial odds from the diplchance setting. */
5609 return server_setting_value_int_get(
5610 server_setting_by_name("diplchance"));
5611 }
5612 fc__fallthrough;
5613 case DRT_CERTAIN:
5614 return 100;
5615 case DRT_NONE:
5616 break;
5617 }
5618
5619 /* The odds of the action not being stopped by its dice roll when the dice
5620 * isn't thrown is 100%. ACTION_ODDS_PCT_DICE_ROLL_NA is above 100% */
5621 return ACTION_ODDS_PCT_DICE_ROLL_NA;
5622}
5623
5624/**********************************************************************/
5627int action_dice_roll_odds(const struct player *act_player,
5628 const struct unit *act_unit,
5629 const struct city *tgt_city,
5630 const struct player *tgt_player,
5631 const struct action *paction)
5632{
5633 int odds = action_dice_roll_initial_odds(paction);
5634 const struct unit_type *actu_type = unit_type_get(act_unit);
5635
5636 fc_assert_action_msg(odds >= 0 && odds <= 100,
5637 odds = 100,
5638 "Bad initial odds for action number %d."
5639 " Does it roll the dice at all?",
5640 paction->id);
5641
5642 /* Let the Action_Odds_Pct effect modify the odds. The advantage of doing
5643 * it this way instead of rolling twice is that Action_Odds_Pct can
5644 * increase the odds. */
5645 odds = odds
5646 + ((odds
5647 * get_target_bonus_effects(nullptr,
5648 &(const struct req_context) {
5649 .player = act_player,
5650 .city = tgt_city,
5651 .unit = act_unit,
5652 .unittype = actu_type,
5653 .action = paction,
5654 },
5655 &(const struct req_context) {
5656 .player = tgt_player,
5657 },
5658 EFT_ACTION_ODDS_PCT))
5659 / 100)
5660 - ((odds
5661 * get_target_bonus_effects(nullptr,
5662 &(const struct req_context) {
5663 .player = tgt_player,
5664 .city = tgt_city,
5665 .unit = act_unit,
5666 .unittype = actu_type,
5667 .action = paction,
5668 },
5669 &(const struct req_context) {
5670 .player = act_player,
5671 },
5672 EFT_ACTION_RESIST_PCT))
5673 / 100);
5674
5675
5676 /* Odds are between 0% and 100%. */
5677 return CLIP(0, odds, 100);
5678}
5679
5680/**********************************************************************/
5683bool action_immune_government(struct government *gov, action_id act)
5684{
5685 struct action *paction = action_by_number(act);
5686
5687 /* Always immune since its not enabled. Doesn't count. */
5688 if (!action_is_in_use(paction)) {
5689 return FALSE;
5690 }
5691
5692 action_enabler_list_iterate(action_enablers_for_action(act), enabler) {
5693 if (requirement_fulfilled_by_government(gov, &(enabler->target_reqs))) {
5694 return FALSE;
5695 }
5696 } action_enabler_list_iterate_end;
5697
5698 return TRUE;
5699}
5700
5701/**********************************************************************/
5706static bool is_target_possible(const action_id wanted_action,
5707 const struct player *actor_player,
5708 const struct req_context *target)
5709{
5710 action_enabler_list_iterate(action_enablers_for_action(wanted_action),
5711 enabler) {
5712 if (are_reqs_active(target,
5713 &(const struct req_context) {
5714 .player = actor_player,
5715 },
5716 &enabler->target_reqs, RPT_POSSIBLE)) {
5717 return TRUE;
5718 }
5719 } action_enabler_list_iterate_end;
5720
5721 return FALSE;
5722}
5723
5724/**********************************************************************/
5727bool is_action_possible_on_city(action_id act_id,
5728 const struct player *actor_player,
5729 const struct city* target_city)
5730{
5731 fc_assert_ret_val_msg(ATK_CITY == action_id_get_target_kind(act_id),
5732 FALSE, "Action %s is against %s not cities",
5733 action_id_rule_name(act_id),
5734 action_target_kind_name(
5735 action_id_get_target_kind(act_id)));
5736
5737 return is_target_possible(act_id, actor_player,
5738 &(const struct req_context) {
5739 .player = city_owner(target_city),
5740 .city = target_city,
5741 .tile = city_tile(target_city),
5742 });
5743}
5744
5745/**********************************************************************/
5750bool action_maybe_possible_actor_unit(const struct civ_map *nmap,
5751 const action_id act_id,
5752 const struct unit *actor_unit)
5753{
5754 const struct player *actor_player = unit_owner(actor_unit);
5755 const struct req_context actor_ctxt = {
5756 .player = actor_player,
5757 .city = tile_city(unit_tile(actor_unit)),
5758 .tile = unit_tile(actor_unit),
5759 .unit = actor_unit,
5760 .unittype = unit_type_get(actor_unit),
5761 };
5762 const struct action *paction = action_by_number(act_id);
5763
5764 enum fc_tristate result;
5765
5766 fc_assert_ret_val(actor_unit, FALSE);
5767
5768 if (!utype_can_do_action(actor_unit->utype, act_id)) {
5769 /* The unit type can't perform the action. */
5770 return FALSE;
5771 }
5772
5773 result = action_hard_reqs_actor(nmap, paction, &actor_ctxt, FALSE,
5774 unit_home(actor_unit));
5775
5776 if (result == TRI_NO) {
5777 /* The hard requirements aren't fulfilled. */
5778 return FALSE;
5779 }
5780
5781 action_enabler_list_iterate(action_enablers_for_action(act_id),
5782 enabler) {
5783 const enum fc_tristate current
5784 = mke_eval_reqs(actor_player, &actor_ctxt, nullptr,
5785 &enabler->actor_reqs,
5786 /* Needed since no player to evaluate DiplRel
5787 * requirements against. */
5788 RPT_POSSIBLE);
5789
5790 if (current == TRI_YES
5791 || current == TRI_MAYBE) {
5792 /* The ruleset requirements may be fulfilled. */
5793 return TRUE;
5794 }
5795 } action_enabler_list_iterate_end;
5796
5797 /* No action enabler allows this action. */
5798 return FALSE;
5799}
5800
5801/**********************************************************************/
5805bool action_mp_full_makes_legal(const struct unit *actor,
5806 const action_id act_id)
5807{
5808 fc_assert(action_id_exists(act_id) || act_id == ACTION_ANY);
5809
5810 /* Check if full movement points may enable the specified action. */
5811 return !utype_may_act_move_frags(unit_type_get(actor),
5812 act_id,
5813 actor->moves_left)
5814 && utype_may_act_move_frags(unit_type_get(actor),
5815 act_id,
5816 unit_move_rate(actor));
5817}
5818
5819/**********************************************************************/
5828bool action_enabler_utype_possible_actor(const struct action_enabler *ae,
5829 const struct unit_type *act_utype)
5830{
5831 const struct action *paction = enabler_get_action(ae);
5832 struct universal actor_univ = { .kind = VUT_UTYPE,
5833 .value.utype = act_utype };
5834
5835 fc_assert_ret_val(paction != nullptr, FALSE);
5836 fc_assert_ret_val(action_get_actor_kind(paction) == AAK_UNIT, FALSE);
5837 fc_assert_ret_val(act_utype != nullptr, FALSE);
5838
5839 return (action_actor_utype_hard_reqs_ok(paction, act_utype)
5840 && !req_vec_is_impossible_to_fulfill(&ae->actor_reqs)
5841 && universal_fulfills_requirements(FALSE, &ae->actor_reqs,
5842 &actor_univ));
5843}
5844
5845/**********************************************************************/
5855bool action_enabler_possible_actor(const struct action_enabler *ae)
5856{
5857 const struct action *paction = enabler_get_action(ae);
5858
5859 switch (action_get_actor_kind(paction)) {
5860 case AAK_UNIT:
5861 unit_type_iterate(putype) {
5862 if (action_enabler_utype_possible_actor(ae, putype)) {
5863 /* A possible actor unit type has been found. */
5864 return TRUE;
5865 }
5866 } unit_type_iterate_end;
5867
5868 /* No actor detected. */
5869 return FALSE;
5870 case AAK_CITY:
5871 case AAK_PLAYER:
5872 /* Currently can't detect */
5873 return TRUE;
5874 case AAK_COUNT:
5875 fc_assert(action_get_actor_kind(paction) != AAK_COUNT);
5876 break;
5877 }
5878
5879 /* No actor detected. */
5880 return FALSE;
5881}
5882
5883/**********************************************************************/
5890static bool action_has_possible_actor_hard_reqs(struct action *paction)
5891{
5892 switch (action_get_actor_kind(paction)) {
5893 case AAK_UNIT:
5894 unit_type_iterate(putype) {
5895 if (action_actor_utype_hard_reqs_ok(paction, putype)) {
5896 return TRUE;
5897 }
5898 } unit_type_iterate_end;
5899 break;
5900 case AAK_CITY:
5901 case AAK_PLAYER:
5902 /* No ruleset hard reqs atm */
5903 return TRUE;
5904 case AAK_COUNT:
5905 fc_assert(action_get_actor_kind(paction) != AAK_COUNT);
5906 break;
5907 }
5908
5909 /* No actor detected. */
5910 return FALSE;
5911}
5912
5913/**********************************************************************/
5920bool action_is_in_use(struct action *paction)
5921{
5922 struct action_enabler_list *enablers;
5923
5924 if (!action_has_possible_actor_hard_reqs(paction)) {
5925 /* Hard requirements not fulfilled. */
5926 return FALSE;
5927 }
5928
5929 enablers = action_enablers_for_action(paction->id);
5930
5931 action_enabler_list_re_iterate(enablers, ae) {
5932 /* If this iteration finds any entries, action is enabled. */
5933 return TRUE;
5934 } action_enabler_list_re_iterate_end;
5935
5936 /* No non deleted action enabler. */
5937 return FALSE;
5938}
5939
5940/**********************************************************************/
5946bool action_is_internal(struct action *paction)
5947{
5948 return paction != nullptr
5949 && action_has_result(paction, ACTRES_ENABLER_CHECK);
5950}
5951
5952/**********************************************************************/
5962
5963/**********************************************************************/
5966struct action_auto_perf *action_auto_perf_slot_number(const int num)
5967{
5968 fc_assert_ret_val(num >= 0, nullptr);
5969 fc_assert_ret_val(num < MAX_NUM_ACTION_AUTO_PERFORMERS, nullptr);
5970
5971 return &auto_perfs[num];
5972}
5973
5974/**********************************************************************/
5982const struct action_auto_perf *action_auto_perf_by_number(const int num)
5983{
5984 return action_auto_perf_slot_number(num);
5985}
5986
5987/**********************************************************************/
5990bool action_univs_not_blocking(const struct action *paction,
5991 struct universal *actor_uni,
5992 struct universal *target_uni)
5993{
5994 action_enabler_list_iterate(action_enablers_for_action(paction->id),
5995 enab) {
5996 if ((actor_uni == nullptr
5997 || universal_fulfills_requirements(FALSE, &(enab->actor_reqs),
5998 actor_uni))
5999 && (target_uni == nullptr
6000 || universal_fulfills_requirements(FALSE, &(enab->target_reqs),
6001 target_uni))) {
6002 return TRUE;
6003 }
6004 } action_enabler_list_iterate_end;
6005
6006 return FALSE;
6007}
6008
6009/**********************************************************************/
6014void action_array_end(action_id *act_array, int size)
6015{
6016 fc_assert_ret(size <= MAX_NUM_ACTIONS);
6017
6018 if (size < MAX_NUM_ACTIONS) {
6019 /* An action array is terminated by ACTION_NONE */
6020 act_array[size] = ACTION_NONE;
6021 }
6022}
6023
6024/**********************************************************************/
6031void action_array_add_all_by_result(action_id *act_array,
6032 int *position,
6033 enum action_result result)
6034{
6035 action_iterate(act) {
6036 struct action *paction = action_by_number(act);
6037 if (paction->result == result) {
6038 /* Assume one result for each action. */
6039 fc_assert_ret(*position < MAX_NUM_ACTIONS);
6040
6041 act_array[(*position)++] = paction->id;
6042 }
6043 } action_iterate_end;
6044}
6045
6046/**********************************************************************/
6049const char *action_ui_name_default(int act)
6050{
6051 switch ((enum gen_action)act) {
6052 case ACTION_SPY_POISON:
6053 /* TRANS: _Poison City (3% chance of success). */
6054 return N_("%sPoison City%s");
6055 case ACTION_SPY_POISON_ESC:
6056 /* TRANS: _Poison City and Escape (3% chance of success). */
6057 return N_("%sPoison City and Escape%s");
6058 case ACTION_SPY_SABOTAGE_UNIT:
6059 /* TRANS: S_abotage Enemy Unit (3% chance of success). */
6060 return N_("S%sabotage Enemy Unit%s");
6061 case ACTION_SPY_SABOTAGE_UNIT_ESC:
6062 /* TRANS: S_abotage Enemy Unit and Escape (3% chance of success). */
6063 return N_("S%sabotage Enemy Unit and Escape%s");
6064 case ACTION_SPY_BRIBE_UNIT:
6065 /* TRANS: Bribe Enemy _Unit (3% chance of success). */
6066 return N_("Bribe Enemy %sUnit%s");
6067 case ACTION_SPY_BRIBE_STACK:
6068 /* TRANS: Bribe Enemy _Stack (3% chance of success). */
6069 return N_("Bribe Enemy %sStack%s");
6070 case ACTION_SPY_SABOTAGE_CITY:
6071 /* TRANS: _Sabotage City (3% chance of success). */
6072 return N_("%sSabotage City%s");
6073 case ACTION_SPY_SABOTAGE_CITY_ESC:
6074 /* TRANS: _Sabotage City and Escape (3% chance of success). */
6075 return N_("%sSabotage City and Escape%s");
6076 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
6077 /* TRANS: Industria_l Sabotage (3% chance of success). */
6078 return N_("Industria%sl Sabotage%s");
6079 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
6080 /* TRANS: Industria_l Sabotage Production (3% chance of success). */
6081 return N_("Industria%sl Sabotage Production%s");
6082 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
6083 /* TRANS: Industria_l Sabotage and Escape (3% chance of success). */
6084 return N_("Industria%sl Sabotage and Escape%s");
6085 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
6086 /* TRANS: Industria_l Sabotage Production and Escape (3% chance of success). */
6087 return N_("Industria%sl Sabotage Production and Escape%s");
6088 case ACTION_SPY_INCITE_CITY:
6089 /* TRANS: Incite a Re_volt (3% chance of success). */
6090 return N_("Incite a Re%svolt%s");
6091 case ACTION_SPY_INCITE_CITY_ESC:
6092 /* TRANS: Incite a Re_volt and Escape (3% chance of success). */
6093 return N_("Incite a Re%svolt and Escape%s");
6094 case ACTION_ESTABLISH_EMBASSY:
6095 /* TRANS: Establish _Embassy (100% chance of success). */
6096 return N_("Establish %sEmbassy%s");
6097 case ACTION_ESTABLISH_EMBASSY_STAY:
6098 /* TRANS: Becom_e Ambassador (100% chance of success). */
6099 return N_("Becom%se Ambassador%s");
6100 case ACTION_SPY_STEAL_TECH:
6101 /* TRANS: Steal _Technology (3% chance of success). */
6102 return N_("Steal %sTechnology%s");
6103 case ACTION_SPY_STEAL_TECH_ESC:
6104 /* TRANS: Steal _Technology and Escape (3% chance of success). */
6105 return N_("Steal %sTechnology and Escape%s");
6106 case ACTION_SPY_TARGETED_STEAL_TECH:
6107 /* TRANS: In_dustrial Espionage (3% chance of success). */
6108 return N_("In%sdustrial Espionage%s");
6109 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
6110 /* TRANS: In_dustrial Espionage and Escape (3% chance of success). */
6111 return N_("In%sdustrial Espionage and Escape%s");
6112 case ACTION_SPY_INVESTIGATE_CITY:
6113 /* TRANS: _Investigate City (100% chance of success). */
6114 return N_("%sInvestigate City%s");
6115 case ACTION_INV_CITY_SPEND:
6116 /* TRANS: _Investigate City (spends the unit) (100% chance of
6117 * success). */
6118 return N_("%sInvestigate City (spends the unit)%s");
6119 case ACTION_SPY_STEAL_GOLD:
6120 /* TRANS: Steal _Gold (100% chance of success). */
6121 return N_("Steal %sGold%s");
6122 case ACTION_SPY_STEAL_GOLD_ESC:
6123 /* TRANS: Steal _Gold and Escape (100% chance of success). */
6124 return N_("Steal %sGold and Escape%s");
6125 case ACTION_SPY_SPREAD_PLAGUE:
6126 /* TRANS: Spread _Plague (100% chance of success). */
6127 return N_("Spread %sPlague%s");
6128 case ACTION_STEAL_MAPS:
6129 /* TRANS: Steal _Maps (100% chance of success). */
6130 return N_("Steal %sMaps%s");
6131 case ACTION_STEAL_MAPS_ESC:
6132 /* TRANS: Steal _Maps and Escape (100% chance of success). */
6133 return N_("Steal %sMaps and Escape%s");
6134 case ACTION_TRADE_ROUTE:
6135 /* TRANS: Establish Trade _Route (100% chance of success). */
6136 return N_("Establish Trade %sRoute%s");
6137 case ACTION_MARKETPLACE:
6138 /* TRANS: Enter _Marketplace (100% chance of success). */
6139 return N_("Enter %sMarketplace%s");
6140 case ACTION_HELP_WONDER:
6141 /* TRANS: Help _build Wonder (100% chance of success). */
6142 return N_("Help %sbuild Wonder%s");
6143 case ACTION_CAPTURE_UNITS:
6144 /* TRANS: _Capture Units (100% chance of success). */
6145 return N_("%sCapture Units%s");
6146 case ACTION_EXPEL_UNIT:
6147 /* TRANS: _Expel Unit (100% chance of success). */
6148 return N_("%sExpel Unit%s");
6149 case ACTION_FOUND_CITY:
6150 /* TRANS: _Found City (100% chance of success). */
6151 return N_("%sFound City%s");
6152 case ACTION_JOIN_CITY:
6153 /* TRANS: _Join City (100% chance of success). */
6154 return N_("%sJoin City%s");
6155 case ACTION_BOMBARD:
6156 /* TRANS: B_ombard (100% chance of success). */
6157 return N_("B%sombard%s");
6158 case ACTION_BOMBARD2:
6159 /* TRANS: B_ombard 2 (100% chance of success). */
6160 return N_("B%sombard 2%s");
6161 case ACTION_BOMBARD3:
6162 /* TRANS: B_ombard 3 (100% chance of success). */
6163 return N_("B%sombard 3%s");
6164 case ACTION_BOMBARD4:
6165 /* TRANS: B_ombard 4 (100% chance of success). */
6166 return N_("B%sombard 4%s");
6167 case ACTION_BOMBARD_LETHAL:
6168 case ACTION_BOMBARD_LETHAL2:
6169 /* TRANS: Lethal B_ombard (100% chance of success). */
6170 return N_("Lethal B%sombard%s");
6171 case ACTION_SPY_NUKE:
6172 /* TRANS: Suitcase _Nuke (100% chance of success). */
6173 return N_("Suitcase %sNuke%s");
6174 case ACTION_SPY_NUKE_ESC:
6175 /* TRANS: Suitcase _Nuke and Escape (100% chance of success). */
6176 return N_("Suitcase %sNuke and Escape%s");
6177 case ACTION_NUKE:
6178 /* TRANS: Explode _Nuclear (100% chance of success). */
6179 return N_("Explode %sNuclear%s");
6180 case ACTION_NUKE_CITY:
6181 /* TRANS: _Nuke City (100% chance of success). */
6182 return N_("%sNuke City%s");
6183 case ACTION_NUKE_UNITS:
6184 /* TRANS: _Nuke Units (100% chance of success). */
6185 return N_("%sNuke Units%s");
6186 case ACTION_DESTROY_CITY:
6187 /* TRANS: Destroy _City (100% chance of success). */
6188 return N_("Destroy %sCity%s");
6189 case ACTION_DISBAND_UNIT_RECOVER:
6190 /* TRANS: Dis_band recovering production (100% chance of success). */
6191 return N_("Dis%sband recovering production%s");
6192 case ACTION_DISBAND_UNIT:
6193 /* TRANS: Dis_band without recovering production (100% chance of success). */
6194 return N_("Dis%sband without recovering production%s");
6195 case ACTION_HOME_CITY:
6196 /* TRANS: Set _Home City (100% chance of success). */
6197 return N_("Set %sHome City%s");
6198 case ACTION_HOMELESS:
6199 /* TRANS: Make _Homeless (100% chance of success). */
6200 return N_("Make %sHomeless%s");
6201 case ACTION_UPGRADE_UNIT:
6202 /* TRANS: _Upgrade Unit (100% chance of success). */
6203 return N_("%sUpgrade Unit%s");
6204 case ACTION_PARADROP:
6205 /* TRANS: Drop _Paratrooper (100% chance of success). */
6206 return N_("Drop %sParatrooper%s");
6207 case ACTION_PARADROP_CONQUER:
6208 /* TRANS: Drop _Paratrooper (100% chance of success). */
6209 return N_("Drop %sParatrooper%s");
6210 case ACTION_PARADROP_FRIGHTEN:
6211 /* TRANS: Drop _Paratrooper (100% chance of success). */
6212 return N_("Drop %sParatrooper%s");
6213 case ACTION_PARADROP_FRIGHTEN_CONQUER:
6214 /* TRANS: Drop _Paratrooper (100% chance of success). */
6215 return N_("Drop %sParatrooper%s");
6216 case ACTION_PARADROP_ENTER:
6217 /* TRANS: Drop _Paratrooper (100% chance of success). */
6218 return N_("Drop %sParatrooper%s");
6219 case ACTION_PARADROP_ENTER_CONQUER:
6220 /* TRANS: Drop _Paratrooper (100% chance of success). */
6221 return N_("Drop %sParatrooper%s");
6222 case ACTION_AIRLIFT:
6223 /* TRANS: _Airlift to City (100% chance of success). */
6224 return N_("%sAirlift to City%s");
6225 case ACTION_ATTACK:
6226 case ACTION_ATTACK2:
6227 /* TRANS: _Attack (100% chance of success). */
6228 return N_("%sAttack%s");
6229 case ACTION_SUICIDE_ATTACK:
6230 case ACTION_SUICIDE_ATTACK2:
6231 /* TRANS: _Suicide Attack (100% chance of success). */
6232 return N_("%sSuicide Attack%s");
6233 case ACTION_WIPE_UNITS:
6234 /* TRANS: _Wipe Units (100% chance of success). */
6235 return N_("%sWipe Units%s");
6236 case ACTION_COLLECT_RANSOM:
6237 /* TRANS: Collect _Ransom (100% chance of success). */
6238 return N_("Collect %sRansom%s");
6239 case ACTION_STRIKE_BUILDING:
6240 /* TRANS: Surgical Str_ike Building (100% chance of success). */
6241 return N_("Surgical Str%sike Building%s");
6242 case ACTION_STRIKE_PRODUCTION:
6243 /* TRANS: Surgical Str_ike Production (100% chance of success). */
6244 return N_("Surgical Str%sike Production%s");
6245 case ACTION_CONQUER_CITY_SHRINK:
6246 case ACTION_CONQUER_CITY_SHRINK3:
6247 case ACTION_CONQUER_CITY_SHRINK4:
6248 /* TRANS: _Conquer City (100% chance of success). */
6249 return N_("%sConquer City%s");
6250 case ACTION_CONQUER_CITY_SHRINK2:
6251 /* TRANS: _Conquer City 2 (100% chance of success). */
6252 return N_("%sConquer City 2%s");
6253 case ACTION_CONQUER_EXTRAS:
6254 case ACTION_CONQUER_EXTRAS3:
6255 case ACTION_CONQUER_EXTRAS4:
6256 /* TRANS: _Conquer Extras (100% chance of success). */
6257 return N_("%sConquer Extras%s");
6258 case ACTION_CONQUER_EXTRAS2:
6259 /* TRANS: _Conquer Extras 2 (100% chance of success). */
6260 return N_("%sConquer Extras 2%s");
6261 case ACTION_HEAL_UNIT:
6262 case ACTION_HEAL_UNIT2:
6263 /* TRANS: Heal _Unit (3% chance of success). */
6264 return N_("Heal %sUnit%s");
6265 case ACTION_TRANSFORM_TERRAIN:
6266 case ACTION_TRANSFORM_TERRAIN2:
6267 /* TRANS: _Transform Terrain (3% chance of success). */
6268 return N_("%sTransform Terrain%s");
6269 case ACTION_CULTIVATE:
6270 case ACTION_CULTIVATE2:
6271 /* TRANS: Transform by _Cultivating (3% chance of success). */
6272 return N_("Transform by %sCultivating%s");
6273 case ACTION_PLANT:
6274 case ACTION_PLANT2:
6275 /* TRANS: Transform by _Planting (3% chance of success). */
6276 return N_("Transform by %sPlanting%s");
6277 case ACTION_PILLAGE:
6278 case ACTION_PILLAGE2:
6279 /* TRANS: Pilla_ge (100% chance of success). */
6280 return N_("Pilla%sge%s");
6281 case ACTION_CLEAN:
6282 case ACTION_CLEAN2:
6283 /* TRANS: Clean (100% chance of success). */
6284 return N_("%sClean%s");
6285 case ACTION_FORTIFY:
6286 case ACTION_FORTIFY2:
6287 /* TRANS: _Fortify (100% chance of success). */
6288 return N_("%sFortify%s");
6289 case ACTION_ROAD:
6290 case ACTION_ROAD2:
6291 /* TRANS: Build _Road (100% chance of success). */
6292 return N_("Build %sRoad%s");
6293 case ACTION_CONVERT:
6294 /* TRANS: _Convert Unit (100% chance of success). */
6295 return N_("%sConvert Unit%s");
6296 case ACTION_BASE:
6297 case ACTION_BASE2:
6298 /* TRANS: _Build Base (100% chance of success). */
6299 return N_("%sBuild Base%s");
6300 case ACTION_MINE:
6301 case ACTION_MINE2:
6302 /* TRANS: Build _Mine (100% chance of success). */
6303 return N_("Build %sMine%s");
6304 case ACTION_IRRIGATE:
6305 case ACTION_IRRIGATE2:
6306 /* TRANS: Build _Irrigation (100% chance of success). */
6307 return N_("Build %sIrrigation%s");
6308 case ACTION_TRANSPORT_DEBOARD:
6309 /* TRANS: _Deboard (100% chance of success). */
6310 return N_("%sDeboard%s");
6311 case ACTION_TRANSPORT_BOARD:
6312 case ACTION_TRANSPORT_BOARD2:
6313 case ACTION_TRANSPORT_BOARD3:
6314 /* TRANS: _Board (100% chance of success). */
6315 return N_("%sBoard%s");
6316 case ACTION_TRANSPORT_EMBARK:
6317 case ACTION_TRANSPORT_EMBARK2:
6318 case ACTION_TRANSPORT_EMBARK3:
6319 case ACTION_TRANSPORT_EMBARK4:
6320 /* TRANS: _Embark (100% chance of success). */
6321 return N_("%sEmbark%s");
6322 case ACTION_TRANSPORT_UNLOAD:
6323 /* TRANS: _Unload (100% chance of success). */
6324 return N_("%sUnload%s");
6325 case ACTION_TRANSPORT_LOAD:
6326 case ACTION_TRANSPORT_LOAD2:
6327 case ACTION_TRANSPORT_LOAD3:
6328 /* TRANS: _Load (100% chance of success). */
6329 return N_("%sLoad%s");
6330 case ACTION_TRANSPORT_DISEMBARK1:
6331 case ACTION_TRANSPORT_DISEMBARK3:
6332 case ACTION_TRANSPORT_DISEMBARK4:
6333 /* TRANS: _Disembark (100% chance of success). */
6334 return N_("%sDisembark%s");
6335 case ACTION_TRANSPORT_DISEMBARK2:
6336 /* TRANS: _Disembark 2 (100% chance of success). */
6337 return N_("%sDisembark 2%s");
6338 case ACTION_SPY_ATTACK:
6339 /* TRANS: _Eliminate Diplomat (100% chance of success). */
6340 return N_("%sEliminate Diplomat%s");
6341 case ACTION_HUT_ENTER:
6342 case ACTION_HUT_ENTER2:
6343 case ACTION_HUT_ENTER3:
6344 case ACTION_HUT_ENTER4:
6345 /* TRANS: Enter _Hut (100% chance of success). */
6346 return N_("Enter %sHut%s");
6347 case ACTION_HUT_FRIGHTEN:
6348 case ACTION_HUT_FRIGHTEN2:
6349 case ACTION_HUT_FRIGHTEN3:
6350 case ACTION_HUT_FRIGHTEN4:
6351 /* TRANS: Frighten _Hut (100% chance of success). */
6352 return N_("Frighten %sHut%s");
6353 case ACTION_UNIT_MOVE:
6354 case ACTION_UNIT_MOVE2:
6355 case ACTION_UNIT_MOVE3:
6356 /* TRANS: Regular _Move (100% chance of success). */
6357 return N_("Regular %sMove%s");
6358 case ACTION_TELEPORT:
6359 case ACTION_TELEPORT2:
6360 case ACTION_TELEPORT3:
6361 /* TRANS: _Teleport (100% chance of success). */
6362 return N_("%sTeleport%s");
6363 case ACTION_TELEPORT_CONQUER:
6364 /* TRANS: _Teleport (100% chance of success). */
6365 return N_("%sTeleport%s");
6366 case ACTION_TELEPORT_FRIGHTEN:
6367 /* TRANS: _Teleport (100% chance of success). */
6368 return N_("%sTeleport%s");
6369 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
6370 /* TRANS: _Teleport (100% chance of success). */
6371 return N_("%sTeleport%s");
6372 case ACTION_TELEPORT_ENTER:
6373 /* TRANS: _Teleport (100% chance of success). */
6374 return N_("%sTeleport%s");
6375 case ACTION_TELEPORT_ENTER_CONQUER:
6376 /* TRANS: _Teleport (100% chance of success). */
6377 return N_("%sTeleport%s");
6378 case ACTION_SPY_ESCAPE:
6379 /* TRANS: _Escape To Nearest City (100% chance of success). */
6380 return N_("%sEscape To Nearest City%s");
6381 case ACTION_SCOUT:
6382 /* TRANS: _Scout (100% chance of success). */
6383 return N_("%sScout%s");
6384 case ACTION_USER_ACTION1:
6385 /* TRANS: _User Action 1 (100% chance of success). */
6386 return N_("%sUser Action 1%s");
6387 case ACTION_USER_ACTION2:
6388 /* TRANS: _User Action 2 (100% chance of success). */
6389 return N_("%sUser Action 2%s");
6390 case ACTION_USER_ACTION3:
6391 /* TRANS: _User Action 3 (100% chance of success). */
6392 return N_("%sUser Action 3%s");
6393 case ACTION_USER_ACTION4:
6394 /* TRANS: _User Action 4 (100% chance of success). */
6395 return N_("%sUser Action 4%s");
6396 case ACTION_GAIN_VETERANCY:
6397 return N_("%sGain Veterancy%s");
6398 case ACTION_ESCAPE:
6399 return N_("%sEscape%s");
6400 case ACTION_CIVIL_WAR:
6401 return N_("%sCivil War%s");
6402 case ACTION_FINISH_UNIT:
6403 return N_("Finish %sUnit%s");
6404 case ACTION_FINISH_BUILDING:
6405 return N_("Finish %sBuilding%s");
6406 case ACTION_COUNT:
6407 fc_assert(act != ACTION_COUNT);
6408 break;
6409 }
6410
6411 return nullptr;
6412}
6413
6414/**********************************************************************/
6420const char *action_min_range_ruleset_var_name(int act)
6421{
6422 switch ((enum gen_action)act) {
6423 case ACTION_SPY_POISON:
6424 case ACTION_SPY_POISON_ESC:
6425 case ACTION_SPY_SABOTAGE_UNIT:
6426 case ACTION_SPY_SABOTAGE_UNIT_ESC:
6427 case ACTION_SPY_BRIBE_UNIT:
6428 case ACTION_SPY_BRIBE_STACK:
6429 case ACTION_SPY_SABOTAGE_CITY:
6430 case ACTION_SPY_SABOTAGE_CITY_ESC:
6431 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
6432 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
6433 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
6434 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
6435 case ACTION_SPY_INCITE_CITY:
6436 case ACTION_SPY_INCITE_CITY_ESC:
6437 case ACTION_ESTABLISH_EMBASSY:
6438 case ACTION_ESTABLISH_EMBASSY_STAY:
6439 case ACTION_SPY_STEAL_TECH:
6440 case ACTION_SPY_STEAL_TECH_ESC:
6441 case ACTION_SPY_TARGETED_STEAL_TECH:
6442 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
6443 case ACTION_SPY_INVESTIGATE_CITY:
6444 case ACTION_INV_CITY_SPEND:
6445 case ACTION_SPY_STEAL_GOLD:
6446 case ACTION_SPY_STEAL_GOLD_ESC:
6447 case ACTION_SPY_SPREAD_PLAGUE:
6448 case ACTION_STEAL_MAPS:
6449 case ACTION_STEAL_MAPS_ESC:
6450 case ACTION_TRADE_ROUTE:
6451 case ACTION_MARKETPLACE:
6452 case ACTION_HELP_WONDER:
6453 case ACTION_CAPTURE_UNITS:
6454 case ACTION_EXPEL_UNIT:
6455 case ACTION_FOUND_CITY:
6456 case ACTION_JOIN_CITY:
6457 case ACTION_SPY_NUKE:
6458 case ACTION_SPY_NUKE_ESC:
6459 case ACTION_DESTROY_CITY:
6460 case ACTION_DISBAND_UNIT_RECOVER:
6461 case ACTION_DISBAND_UNIT:
6462 case ACTION_HOME_CITY:
6463 case ACTION_HOMELESS:
6464 case ACTION_UPGRADE_UNIT:
6465 case ACTION_PARADROP:
6466 case ACTION_PARADROP_CONQUER:
6467 case ACTION_PARADROP_FRIGHTEN:
6468 case ACTION_PARADROP_FRIGHTEN_CONQUER:
6469 case ACTION_PARADROP_ENTER:
6470 case ACTION_PARADROP_ENTER_CONQUER:
6471 case ACTION_AIRLIFT:
6472 case ACTION_ATTACK:
6473 case ACTION_ATTACK2:
6474 case ACTION_SUICIDE_ATTACK:
6475 case ACTION_SUICIDE_ATTACK2:
6476 case ACTION_WIPE_UNITS:
6477 case ACTION_COLLECT_RANSOM:
6478 case ACTION_STRIKE_BUILDING:
6479 case ACTION_STRIKE_PRODUCTION:
6480 case ACTION_CONQUER_CITY_SHRINK:
6481 case ACTION_CONQUER_CITY_SHRINK2:
6482 case ACTION_CONQUER_CITY_SHRINK3:
6483 case ACTION_CONQUER_CITY_SHRINK4:
6484 case ACTION_HEAL_UNIT:
6485 case ACTION_HEAL_UNIT2:
6486 case ACTION_TRANSFORM_TERRAIN:
6487 case ACTION_TRANSFORM_TERRAIN2:
6488 case ACTION_CULTIVATE:
6489 case ACTION_CULTIVATE2:
6490 case ACTION_PLANT:
6491 case ACTION_PLANT2:
6492 case ACTION_PILLAGE:
6493 case ACTION_PILLAGE2:
6494 case ACTION_CLEAN:
6495 case ACTION_CLEAN2:
6496 case ACTION_FORTIFY:
6497 case ACTION_FORTIFY2:
6498 case ACTION_ROAD:
6499 case ACTION_ROAD2:
6500 case ACTION_CONVERT:
6501 case ACTION_BASE:
6502 case ACTION_BASE2:
6503 case ACTION_MINE:
6504 case ACTION_MINE2:
6505 case ACTION_IRRIGATE:
6506 case ACTION_IRRIGATE2:
6507 case ACTION_TRANSPORT_DEBOARD:
6508 case ACTION_TRANSPORT_BOARD:
6509 case ACTION_TRANSPORT_BOARD2:
6510 case ACTION_TRANSPORT_BOARD3:
6511 case ACTION_TRANSPORT_EMBARK:
6512 case ACTION_TRANSPORT_EMBARK2:
6513 case ACTION_TRANSPORT_EMBARK3:
6514 case ACTION_TRANSPORT_EMBARK4:
6515 case ACTION_TRANSPORT_UNLOAD:
6516 case ACTION_TRANSPORT_LOAD:
6517 case ACTION_TRANSPORT_LOAD2:
6518 case ACTION_TRANSPORT_LOAD3:
6519 case ACTION_TRANSPORT_DISEMBARK1:
6520 case ACTION_TRANSPORT_DISEMBARK2:
6521 case ACTION_TRANSPORT_DISEMBARK3:
6522 case ACTION_TRANSPORT_DISEMBARK4:
6523 case ACTION_BOMBARD:
6524 case ACTION_BOMBARD2:
6525 case ACTION_BOMBARD3:
6526 case ACTION_BOMBARD4:
6527 case ACTION_BOMBARD_LETHAL:
6528 case ACTION_BOMBARD_LETHAL2:
6529 case ACTION_SPY_ATTACK:
6530 case ACTION_CONQUER_EXTRAS:
6531 case ACTION_CONQUER_EXTRAS2:
6532 case ACTION_CONQUER_EXTRAS3:
6533 case ACTION_CONQUER_EXTRAS4:
6534 case ACTION_HUT_ENTER:
6535 case ACTION_HUT_ENTER2:
6536 case ACTION_HUT_ENTER3:
6537 case ACTION_HUT_ENTER4:
6538 case ACTION_HUT_FRIGHTEN:
6539 case ACTION_HUT_FRIGHTEN2:
6540 case ACTION_HUT_FRIGHTEN4:
6541 case ACTION_HUT_FRIGHTEN3:
6542 case ACTION_UNIT_MOVE:
6543 case ACTION_UNIT_MOVE2:
6544 case ACTION_UNIT_MOVE3:
6545 case ACTION_SPY_ESCAPE:
6546 case ACTION_SCOUT:
6547 case ACTION_GAIN_VETERANCY:
6548 case ACTION_ESCAPE:
6549 case ACTION_CIVIL_WAR:
6550 case ACTION_FINISH_UNIT:
6551 case ACTION_FINISH_BUILDING:
6552 /* Min range is not ruleset changeable */
6553 return nullptr;
6554 case ACTION_NUKE:
6555 return "explode_nuclear_min_range";
6556 case ACTION_NUKE_CITY:
6557 return "nuke_city_min_range";
6558 case ACTION_NUKE_UNITS:
6559 return "nuke_units_min_range";
6560 case ACTION_TELEPORT:
6561 return "teleport_min_range";
6562 case ACTION_TELEPORT2:
6563 return "teleport_2_min_range";
6564 case ACTION_TELEPORT3:
6565 return "teleport_3_min_range";
6566 case ACTION_TELEPORT_CONQUER:
6567 return "teleport_conquer_min_range";
6568 case ACTION_TELEPORT_FRIGHTEN:
6569 return "teleport_frighten_min_range";
6570 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
6571 return "teleport_frighten_conquer_min_range";
6572 case ACTION_TELEPORT_ENTER:
6573 return "teleport_enter_min_range";
6574 case ACTION_TELEPORT_ENTER_CONQUER:
6575 return "teleport_enter_conquer_min_range";
6576 case ACTION_USER_ACTION1:
6577 return "user_action_1_min_range";
6578 case ACTION_USER_ACTION2:
6579 return "user_action_2_min_range";
6580 case ACTION_USER_ACTION3:
6581 return "user_action_3_min_range";
6582 case ACTION_USER_ACTION4:
6583 return "user_action_4_min_range";
6584 case ACTION_COUNT:
6585 break;
6586
6587 ASSERT_UNUSED_ACTION_CASES;
6588 }
6589
6590 fc_assert(act >= 0 && act < ACTION_COUNT);
6591
6592 return nullptr;
6593}
6594
6595/**********************************************************************/
6601const char *action_max_range_ruleset_var_name(int act)
6602{
6603 switch ((enum gen_action)act) {
6604 case ACTION_SPY_POISON:
6605 case ACTION_SPY_POISON_ESC:
6606 case ACTION_SPY_SABOTAGE_UNIT:
6607 case ACTION_SPY_SABOTAGE_UNIT_ESC:
6608 case ACTION_SPY_BRIBE_UNIT:
6609 case ACTION_SPY_BRIBE_STACK:
6610 case ACTION_SPY_SABOTAGE_CITY:
6611 case ACTION_SPY_SABOTAGE_CITY_ESC:
6612 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
6613 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
6614 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
6615 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
6616 case ACTION_SPY_INCITE_CITY:
6617 case ACTION_SPY_INCITE_CITY_ESC:
6618 case ACTION_ESTABLISH_EMBASSY:
6619 case ACTION_ESTABLISH_EMBASSY_STAY:
6620 case ACTION_SPY_STEAL_TECH:
6621 case ACTION_SPY_STEAL_TECH_ESC:
6622 case ACTION_SPY_TARGETED_STEAL_TECH:
6623 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
6624 case ACTION_SPY_INVESTIGATE_CITY:
6625 case ACTION_INV_CITY_SPEND:
6626 case ACTION_SPY_STEAL_GOLD:
6627 case ACTION_SPY_STEAL_GOLD_ESC:
6628 case ACTION_SPY_SPREAD_PLAGUE:
6629 case ACTION_STEAL_MAPS:
6630 case ACTION_STEAL_MAPS_ESC:
6631 case ACTION_TRADE_ROUTE:
6632 case ACTION_MARKETPLACE:
6633 case ACTION_CAPTURE_UNITS:
6634 case ACTION_EXPEL_UNIT:
6635 case ACTION_FOUND_CITY:
6636 case ACTION_JOIN_CITY:
6637 case ACTION_SPY_NUKE:
6638 case ACTION_SPY_NUKE_ESC:
6639 case ACTION_DESTROY_CITY:
6640 case ACTION_DISBAND_UNIT:
6641 case ACTION_HOME_CITY:
6642 case ACTION_HOMELESS:
6643 case ACTION_UPGRADE_UNIT:
6644 case ACTION_PARADROP:
6645 case ACTION_PARADROP_CONQUER:
6646 case ACTION_PARADROP_FRIGHTEN:
6647 case ACTION_PARADROP_FRIGHTEN_CONQUER:
6648 case ACTION_PARADROP_ENTER:
6649 case ACTION_PARADROP_ENTER_CONQUER:
6650 case ACTION_ATTACK:
6651 case ACTION_ATTACK2:
6652 case ACTION_SUICIDE_ATTACK:
6653 case ACTION_SUICIDE_ATTACK2:
6654 case ACTION_WIPE_UNITS:
6655 case ACTION_COLLECT_RANSOM:
6656 case ACTION_STRIKE_BUILDING:
6657 case ACTION_STRIKE_PRODUCTION:
6658 case ACTION_CONQUER_CITY_SHRINK:
6659 case ACTION_CONQUER_CITY_SHRINK2:
6660 case ACTION_CONQUER_CITY_SHRINK3:
6661 case ACTION_CONQUER_CITY_SHRINK4:
6662 case ACTION_HEAL_UNIT:
6663 case ACTION_HEAL_UNIT2:
6664 case ACTION_TRANSFORM_TERRAIN:
6665 case ACTION_TRANSFORM_TERRAIN2:
6666 case ACTION_CULTIVATE:
6667 case ACTION_CULTIVATE2:
6668 case ACTION_PLANT:
6669 case ACTION_PLANT2:
6670 case ACTION_PILLAGE:
6671 case ACTION_PILLAGE2:
6672 case ACTION_CLEAN:
6673 case ACTION_CLEAN2:
6674 case ACTION_FORTIFY:
6675 case ACTION_FORTIFY2:
6676 case ACTION_ROAD:
6677 case ACTION_ROAD2:
6678 case ACTION_CONVERT:
6679 case ACTION_BASE:
6680 case ACTION_BASE2:
6681 case ACTION_MINE:
6682 case ACTION_MINE2:
6683 case ACTION_IRRIGATE:
6684 case ACTION_IRRIGATE2:
6685 case ACTION_TRANSPORT_DEBOARD:
6686 case ACTION_TRANSPORT_BOARD:
6687 case ACTION_TRANSPORT_BOARD2:
6688 case ACTION_TRANSPORT_BOARD3:
6689 case ACTION_TRANSPORT_EMBARK:
6690 case ACTION_TRANSPORT_EMBARK2:
6691 case ACTION_TRANSPORT_EMBARK3:
6692 case ACTION_TRANSPORT_EMBARK4:
6693 case ACTION_TRANSPORT_UNLOAD:
6694 case ACTION_TRANSPORT_LOAD:
6695 case ACTION_TRANSPORT_LOAD2:
6696 case ACTION_TRANSPORT_LOAD3:
6697 case ACTION_TRANSPORT_DISEMBARK1:
6698 case ACTION_TRANSPORT_DISEMBARK2:
6699 case ACTION_TRANSPORT_DISEMBARK3:
6700 case ACTION_TRANSPORT_DISEMBARK4:
6701 case ACTION_SPY_ATTACK:
6702 case ACTION_CONQUER_EXTRAS:
6703 case ACTION_CONQUER_EXTRAS2:
6704 case ACTION_CONQUER_EXTRAS3:
6705 case ACTION_CONQUER_EXTRAS4:
6706 case ACTION_HUT_ENTER:
6707 case ACTION_HUT_ENTER2:
6708 case ACTION_HUT_ENTER3:
6709 case ACTION_HUT_ENTER4:
6710 case ACTION_HUT_FRIGHTEN:
6711 case ACTION_HUT_FRIGHTEN2:
6712 case ACTION_HUT_FRIGHTEN3:
6713 case ACTION_HUT_FRIGHTEN4:
6714 case ACTION_UNIT_MOVE:
6715 case ACTION_UNIT_MOVE2:
6716 case ACTION_UNIT_MOVE3:
6717 case ACTION_SPY_ESCAPE:
6718 case ACTION_GAIN_VETERANCY:
6719 case ACTION_ESCAPE:
6720 case ACTION_CIVIL_WAR:
6721 case ACTION_FINISH_UNIT:
6722 case ACTION_FINISH_BUILDING:
6723 /* Max range is not ruleset changeable */
6724 return nullptr;
6725 case ACTION_HELP_WONDER:
6726 return "help_wonder_max_range";
6727 case ACTION_DISBAND_UNIT_RECOVER:
6728 return "disband_unit_recover_max_range";
6729 case ACTION_BOMBARD:
6730 return "bombard_max_range";
6731 case ACTION_BOMBARD2:
6732 return "bombard_2_max_range";
6733 case ACTION_BOMBARD3:
6734 return "bombard_3_max_range";
6735 case ACTION_BOMBARD4:
6736 return "bombard_4_max_range";
6737 case ACTION_BOMBARD_LETHAL:
6738 return "bombard_lethal_max_range";
6739 case ACTION_BOMBARD_LETHAL2:
6740 return "bombard_lethal_2_max_range";
6741 case ACTION_NUKE:
6742 return "explode_nuclear_max_range";
6743 case ACTION_NUKE_CITY:
6744 return "nuke_city_max_range";
6745 case ACTION_NUKE_UNITS:
6746 return "nuke_units_max_range";
6747 case ACTION_AIRLIFT:
6748 return "airlift_max_range";
6749 case ACTION_TELEPORT:
6750 return "teleport_max_range";
6751 case ACTION_TELEPORT2:
6752 return "teleport_2_max_range";
6753 case ACTION_TELEPORT3:
6754 return "teleport_3_max_range";
6755 case ACTION_TELEPORT_CONQUER:
6756 return "teleport_conquer_max_range";
6757 case ACTION_TELEPORT_FRIGHTEN:
6758 return "teleport_frighten_max_range";
6759 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
6760 return "teleport_frighten_conquer_max_range";
6761 case ACTION_TELEPORT_ENTER:
6762 return "teleport_enter_max_range";
6763 case ACTION_TELEPORT_ENTER_CONQUER:
6764 return "teleport_enter_conquer_max_range";
6765 case ACTION_SCOUT:
6766 return "scout_max_range";
6767 case ACTION_USER_ACTION1:
6768 return "user_action_1_max_range";
6769 case ACTION_USER_ACTION2:
6770 return "user_action_2_max_range";
6771 case ACTION_USER_ACTION3:
6772 return "user_action_3_max_range";
6773 case ACTION_USER_ACTION4:
6774 return "user_action_4_max_range";
6775 case ACTION_COUNT:
6776 break;
6777
6778 ASSERT_UNUSED_ACTION_CASES;
6779 }
6780
6781 fc_assert(act >= 0 && act < ACTION_COUNT);
6782
6783 return nullptr;
6784}
6785
6786/**********************************************************************/
6792const char *action_target_kind_ruleset_var_name(int act)
6793{
6794 switch ((enum gen_action)act) {
6795 case ACTION_SPY_POISON:
6796 case ACTION_SPY_POISON_ESC:
6797 case ACTION_SPY_SABOTAGE_UNIT:
6798 case ACTION_SPY_SABOTAGE_UNIT_ESC:
6799 case ACTION_SPY_BRIBE_UNIT:
6800 case ACTION_SPY_BRIBE_STACK:
6801 case ACTION_SPY_SABOTAGE_CITY:
6802 case ACTION_SPY_SABOTAGE_CITY_ESC:
6803 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
6804 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
6805 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
6806 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
6807 case ACTION_SPY_INCITE_CITY:
6808 case ACTION_SPY_INCITE_CITY_ESC:
6809 case ACTION_ESTABLISH_EMBASSY:
6810 case ACTION_ESTABLISH_EMBASSY_STAY:
6811 case ACTION_SPY_STEAL_TECH:
6812 case ACTION_SPY_STEAL_TECH_ESC:
6813 case ACTION_SPY_TARGETED_STEAL_TECH:
6814 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
6815 case ACTION_SPY_INVESTIGATE_CITY:
6816 case ACTION_INV_CITY_SPEND:
6817 case ACTION_SPY_STEAL_GOLD:
6818 case ACTION_SPY_STEAL_GOLD_ESC:
6819 case ACTION_SPY_SPREAD_PLAGUE:
6820 case ACTION_STEAL_MAPS:
6821 case ACTION_STEAL_MAPS_ESC:
6822 case ACTION_TRADE_ROUTE:
6823 case ACTION_MARKETPLACE:
6824 case ACTION_HELP_WONDER:
6825 case ACTION_CAPTURE_UNITS:
6826 case ACTION_EXPEL_UNIT:
6827 case ACTION_FOUND_CITY:
6828 case ACTION_JOIN_CITY:
6829 case ACTION_SPY_NUKE:
6830 case ACTION_SPY_NUKE_ESC:
6831 case ACTION_NUKE_UNITS:
6832 case ACTION_DESTROY_CITY:
6833 case ACTION_DISBAND_UNIT_RECOVER:
6834 case ACTION_DISBAND_UNIT:
6835 case ACTION_HOME_CITY:
6836 case ACTION_HOMELESS:
6837 case ACTION_UPGRADE_UNIT:
6838 case ACTION_PARADROP:
6839 case ACTION_PARADROP_CONQUER:
6840 case ACTION_PARADROP_FRIGHTEN:
6841 case ACTION_PARADROP_FRIGHTEN_CONQUER:
6842 case ACTION_PARADROP_ENTER:
6843 case ACTION_PARADROP_ENTER_CONQUER:
6844 case ACTION_AIRLIFT:
6845 case ACTION_ATTACK:
6846 case ACTION_ATTACK2:
6847 case ACTION_SUICIDE_ATTACK:
6848 case ACTION_SUICIDE_ATTACK2:
6849 case ACTION_WIPE_UNITS:
6850 case ACTION_COLLECT_RANSOM:
6851 case ACTION_STRIKE_BUILDING:
6852 case ACTION_STRIKE_PRODUCTION:
6853 case ACTION_CONQUER_CITY_SHRINK:
6854 case ACTION_CONQUER_CITY_SHRINK2:
6855 case ACTION_CONQUER_CITY_SHRINK3:
6856 case ACTION_CONQUER_CITY_SHRINK4:
6857 case ACTION_HEAL_UNIT:
6858 case ACTION_HEAL_UNIT2:
6859 case ACTION_TRANSFORM_TERRAIN:
6860 case ACTION_TRANSFORM_TERRAIN2:
6861 case ACTION_CULTIVATE:
6862 case ACTION_CULTIVATE2:
6863 case ACTION_PLANT:
6864 case ACTION_PLANT2:
6865 case ACTION_CLEAN:
6866 case ACTION_CLEAN2:
6867 case ACTION_FORTIFY:
6868 case ACTION_FORTIFY2:
6869 case ACTION_ROAD:
6870 case ACTION_ROAD2:
6871 case ACTION_CONVERT:
6872 case ACTION_BASE:
6873 case ACTION_BASE2:
6874 case ACTION_MINE:
6875 case ACTION_MINE2:
6876 case ACTION_IRRIGATE:
6877 case ACTION_IRRIGATE2:
6878 case ACTION_TRANSPORT_DEBOARD:
6879 case ACTION_TRANSPORT_BOARD:
6880 case ACTION_TRANSPORT_BOARD2:
6881 case ACTION_TRANSPORT_BOARD3:
6882 case ACTION_TRANSPORT_EMBARK:
6883 case ACTION_TRANSPORT_EMBARK2:
6884 case ACTION_TRANSPORT_EMBARK3:
6885 case ACTION_TRANSPORT_EMBARK4:
6886 case ACTION_TRANSPORT_UNLOAD:
6887 case ACTION_TRANSPORT_LOAD:
6888 case ACTION_TRANSPORT_LOAD2:
6889 case ACTION_TRANSPORT_LOAD3:
6890 case ACTION_TRANSPORT_DISEMBARK1:
6891 case ACTION_TRANSPORT_DISEMBARK2:
6892 case ACTION_TRANSPORT_DISEMBARK3:
6893 case ACTION_TRANSPORT_DISEMBARK4:
6894 case ACTION_BOMBARD:
6895 case ACTION_BOMBARD2:
6896 case ACTION_BOMBARD3:
6897 case ACTION_BOMBARD4:
6898 case ACTION_BOMBARD_LETHAL:
6899 case ACTION_BOMBARD_LETHAL2:
6900 case ACTION_SPY_ATTACK:
6901 case ACTION_CONQUER_EXTRAS:
6902 case ACTION_CONQUER_EXTRAS2:
6903 case ACTION_CONQUER_EXTRAS3:
6904 case ACTION_CONQUER_EXTRAS4:
6905 case ACTION_HUT_ENTER:
6906 case ACTION_HUT_ENTER2:
6907 case ACTION_HUT_ENTER3:
6908 case ACTION_HUT_ENTER4:
6909 case ACTION_HUT_FRIGHTEN:
6910 case ACTION_HUT_FRIGHTEN2:
6911 case ACTION_HUT_FRIGHTEN3:
6912 case ACTION_HUT_FRIGHTEN4:
6913 case ACTION_UNIT_MOVE:
6914 case ACTION_UNIT_MOVE2:
6915 case ACTION_UNIT_MOVE3:
6916 case ACTION_TELEPORT:
6917 case ACTION_TELEPORT2:
6918 case ACTION_TELEPORT3:
6919 case ACTION_TELEPORT_CONQUER:
6920 case ACTION_TELEPORT_FRIGHTEN:
6921 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
6922 case ACTION_TELEPORT_ENTER:
6923 case ACTION_TELEPORT_ENTER_CONQUER:
6924 case ACTION_SPY_ESCAPE:
6925 case ACTION_SCOUT:
6926 case ACTION_GAIN_VETERANCY:
6927 case ACTION_ESCAPE:
6928 case ACTION_CIVIL_WAR:
6929 case ACTION_FINISH_UNIT:
6930 case ACTION_FINISH_BUILDING:
6931 /* Target kind is not ruleset changeable */
6932 return nullptr;
6933 case ACTION_NUKE:
6934 return "explode_nuclear_target_kind";
6935 case ACTION_NUKE_CITY:
6936 return "nuke_city_target_kind";
6937 case ACTION_PILLAGE:
6938 return "pillage_target_kind";
6939 case ACTION_PILLAGE2:
6940 return "pillage_2_target_kind";
6941 case ACTION_USER_ACTION1:
6942 return "user_action_1_target_kind";
6943 case ACTION_USER_ACTION2:
6944 return "user_action_2_target_kind";
6945 case ACTION_USER_ACTION3:
6946 return "user_action_3_target_kind";
6947 case ACTION_USER_ACTION4:
6948 return "user_action_4_target_kind";
6949 case ACTION_COUNT:
6950 break;
6951
6952 ASSERT_UNUSED_ACTION_CASES;
6953 }
6954
6955 fc_assert(act >= 0 && act < ACTION_COUNT);
6956
6957 return nullptr;
6958}
6959
6960/**********************************************************************/
6967const char *action_actor_consuming_always_ruleset_var_name(action_id act)
6968{
6969 switch ((enum gen_action)act) {
6970 case ACTION_SPY_POISON:
6971 case ACTION_SPY_POISON_ESC:
6972 case ACTION_SPY_SABOTAGE_UNIT:
6973 case ACTION_SPY_SABOTAGE_UNIT_ESC:
6974 case ACTION_SPY_BRIBE_UNIT:
6975 case ACTION_SPY_BRIBE_STACK:
6976 case ACTION_SPY_SABOTAGE_CITY:
6977 case ACTION_SPY_SABOTAGE_CITY_ESC:
6978 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
6979 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
6980 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
6981 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
6982 case ACTION_SPY_INCITE_CITY:
6983 case ACTION_SPY_INCITE_CITY_ESC:
6984 case ACTION_ESTABLISH_EMBASSY:
6985 case ACTION_ESTABLISH_EMBASSY_STAY:
6986 case ACTION_SPY_STEAL_TECH:
6987 case ACTION_SPY_STEAL_TECH_ESC:
6988 case ACTION_SPY_TARGETED_STEAL_TECH:
6989 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
6990 case ACTION_SPY_INVESTIGATE_CITY:
6991 case ACTION_INV_CITY_SPEND:
6992 case ACTION_SPY_STEAL_GOLD:
6993 case ACTION_SPY_STEAL_GOLD_ESC:
6994 case ACTION_STEAL_MAPS:
6995 case ACTION_STEAL_MAPS_ESC:
6996 case ACTION_TRADE_ROUTE:
6997 case ACTION_MARKETPLACE:
6998 case ACTION_HELP_WONDER:
6999 case ACTION_CAPTURE_UNITS:
7000 case ACTION_EXPEL_UNIT:
7001 case ACTION_JOIN_CITY:
7002 case ACTION_SPY_NUKE:
7003 case ACTION_SPY_NUKE_ESC:
7004 case ACTION_DESTROY_CITY:
7005 case ACTION_DISBAND_UNIT_RECOVER:
7006 case ACTION_DISBAND_UNIT:
7007 case ACTION_HOME_CITY:
7008 case ACTION_HOMELESS:
7009 case ACTION_UPGRADE_UNIT:
7010 case ACTION_PARADROP:
7011 case ACTION_PARADROP_CONQUER:
7012 case ACTION_PARADROP_FRIGHTEN:
7013 case ACTION_PARADROP_FRIGHTEN_CONQUER:
7014 case ACTION_PARADROP_ENTER:
7015 case ACTION_PARADROP_ENTER_CONQUER:
7016 case ACTION_AIRLIFT:
7017 case ACTION_ATTACK:
7018 case ACTION_ATTACK2:
7019 case ACTION_SUICIDE_ATTACK:
7020 case ACTION_SUICIDE_ATTACK2:
7021 case ACTION_WIPE_UNITS:
7022 case ACTION_COLLECT_RANSOM:
7023 case ACTION_STRIKE_BUILDING:
7024 case ACTION_STRIKE_PRODUCTION:
7025 case ACTION_CONQUER_CITY_SHRINK:
7026 case ACTION_CONQUER_CITY_SHRINK2:
7027 case ACTION_CONQUER_CITY_SHRINK3:
7028 case ACTION_CONQUER_CITY_SHRINK4:
7029 case ACTION_HEAL_UNIT:
7030 case ACTION_HEAL_UNIT2:
7031 case ACTION_TRANSFORM_TERRAIN:
7032 case ACTION_TRANSFORM_TERRAIN2:
7033 case ACTION_CULTIVATE:
7034 case ACTION_CULTIVATE2:
7035 case ACTION_PLANT:
7036 case ACTION_PLANT2:
7037 case ACTION_PILLAGE:
7038 case ACTION_PILLAGE2:
7039 case ACTION_CLEAN:
7040 case ACTION_CLEAN2:
7041 case ACTION_FORTIFY:
7042 case ACTION_FORTIFY2:
7043 case ACTION_ROAD:
7044 case ACTION_ROAD2:
7045 case ACTION_CONVERT:
7046 case ACTION_BASE:
7047 case ACTION_BASE2:
7048 case ACTION_MINE:
7049 case ACTION_MINE2:
7050 case ACTION_IRRIGATE:
7051 case ACTION_IRRIGATE2:
7052 case ACTION_TRANSPORT_DEBOARD:
7053 case ACTION_TRANSPORT_BOARD:
7054 case ACTION_TRANSPORT_BOARD2:
7055 case ACTION_TRANSPORT_BOARD3:
7056 case ACTION_TRANSPORT_EMBARK:
7057 case ACTION_TRANSPORT_EMBARK2:
7058 case ACTION_TRANSPORT_EMBARK3:
7059 case ACTION_TRANSPORT_EMBARK4:
7060 case ACTION_TRANSPORT_UNLOAD:
7061 case ACTION_TRANSPORT_LOAD:
7062 case ACTION_TRANSPORT_LOAD2:
7063 case ACTION_TRANSPORT_LOAD3:
7064 case ACTION_TRANSPORT_DISEMBARK1:
7065 case ACTION_TRANSPORT_DISEMBARK2:
7066 case ACTION_TRANSPORT_DISEMBARK3:
7067 case ACTION_TRANSPORT_DISEMBARK4:
7068 case ACTION_BOMBARD:
7069 case ACTION_BOMBARD2:
7070 case ACTION_BOMBARD3:
7071 case ACTION_BOMBARD4:
7072 case ACTION_BOMBARD_LETHAL:
7073 case ACTION_BOMBARD_LETHAL2:
7074 case ACTION_SPY_ATTACK:
7075 case ACTION_CONQUER_EXTRAS:
7076 case ACTION_CONQUER_EXTRAS2:
7077 case ACTION_CONQUER_EXTRAS3:
7078 case ACTION_CONQUER_EXTRAS4:
7079 case ACTION_HUT_ENTER:
7080 case ACTION_HUT_ENTER2:
7081 case ACTION_HUT_ENTER3:
7082 case ACTION_HUT_ENTER4:
7083 case ACTION_HUT_FRIGHTEN:
7084 case ACTION_HUT_FRIGHTEN2:
7085 case ACTION_HUT_FRIGHTEN3:
7086 case ACTION_HUT_FRIGHTEN4:
7087 case ACTION_UNIT_MOVE:
7088 case ACTION_UNIT_MOVE2:
7089 case ACTION_UNIT_MOVE3:
7090 case ACTION_TELEPORT:
7091 case ACTION_TELEPORT2:
7092 case ACTION_TELEPORT3:
7093 case ACTION_TELEPORT_CONQUER:
7094 case ACTION_TELEPORT_FRIGHTEN:
7095 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
7096 case ACTION_TELEPORT_ENTER:
7097 case ACTION_TELEPORT_ENTER_CONQUER:
7098 case ACTION_SPY_ESCAPE:
7099 case ACTION_SCOUT:
7100 case ACTION_GAIN_VETERANCY:
7101 case ACTION_ESCAPE:
7102 case ACTION_CIVIL_WAR:
7103 case ACTION_FINISH_UNIT:
7104 case ACTION_FINISH_BUILDING:
7105 /* Actor consuming always is not ruleset changeable */
7106 return nullptr;
7107 case ACTION_FOUND_CITY:
7108 return "found_city_consuming_always";
7109 case ACTION_NUKE:
7110 return "explode_nuclear_consuming_always";
7111 case ACTION_NUKE_CITY:
7112 return "nuke_city_consuming_always";
7113 case ACTION_NUKE_UNITS:
7114 return "nuke_units_consuming_always";
7115 case ACTION_SPY_SPREAD_PLAGUE:
7116 return "spread_plague_actor_consuming_always";
7117 case ACTION_USER_ACTION1:
7118 return "user_action_1_actor_consuming_always";
7119 case ACTION_USER_ACTION2:
7120 return "user_action_2_actor_consuming_always";
7121 case ACTION_USER_ACTION3:
7122 return "user_action_3_actor_consuming_always";
7123 case ACTION_USER_ACTION4:
7124 return "user_action_4_actor_consuming_always";
7125 case ACTION_COUNT:
7126 break;
7127
7128 ASSERT_UNUSED_ACTION_CASES;
7129 }
7130
7131 fc_assert(act >= 0 && act < ACTION_COUNT);
7132
7133 return nullptr;
7134}
7135
7136/**********************************************************************/
7143const char *action_blocked_by_ruleset_var_name(const struct action *act)
7144{
7145 fc_assert_ret_val(act != nullptr, nullptr);
7146
7147 switch ((enum gen_action)action_number(act)) {
7148 case ACTION_MARKETPLACE:
7149 return "enter_marketplace_blocked_by";
7150 case ACTION_BOMBARD:
7151 return "bombard_blocked_by";
7152 case ACTION_BOMBARD2:
7153 return "bombard_2_blocked_by";
7154 case ACTION_BOMBARD3:
7155 return "bombard_3_blocked_by";
7156 case ACTION_BOMBARD4:
7157 return "bombard_4_blocked_by";
7158 case ACTION_BOMBARD_LETHAL:
7159 return "bombard_lethal_blocked_by";
7160 case ACTION_BOMBARD_LETHAL2:
7161 return "bombard_lethal_2_blocked_by";
7162 case ACTION_NUKE:
7163 return "explode_nuclear_blocked_by";
7164 case ACTION_NUKE_CITY:
7165 return "nuke_city_blocked_by";
7166 case ACTION_NUKE_UNITS:
7167 return "nuke_units_blocked_by";
7168 case ACTION_ATTACK:
7169 return "attack_blocked_by";
7170 case ACTION_ATTACK2:
7171 return "attack_2_blocked_by";
7172 case ACTION_SUICIDE_ATTACK:
7173 return "suicide_attack_blocked_by";
7174 case ACTION_SUICIDE_ATTACK2:
7175 return "suicide_attack_2_blocked_by";
7176 case ACTION_WIPE_UNITS:
7177 return "wipe_units_blocked_by";
7178 case ACTION_COLLECT_RANSOM:
7179 return "collect_ransom_blocked_by";
7180 case ACTION_CONQUER_CITY_SHRINK:
7181 return "conquer_city_shrink_blocked_by";
7182 case ACTION_CONQUER_CITY_SHRINK2:
7183 return "conquer_city_shrink_2_blocked_by";
7184 case ACTION_CONQUER_CITY_SHRINK3:
7185 return "conquer_city_shrink_3_blocked_by";
7186 case ACTION_CONQUER_CITY_SHRINK4:
7187 return "conquer_city_shrink_4_blocked_by";
7188 case ACTION_UNIT_MOVE:
7189 return "move_blocked_by";
7190 case ACTION_UNIT_MOVE2:
7191 return "move_2_blocked_by";
7192 case ACTION_UNIT_MOVE3:
7193 return "move_3_blocked_by";
7194 case ACTION_TELEPORT:
7195 return "teleport_blocked_by";
7196 case ACTION_TELEPORT2:
7197 return "teleport_2_blocked_by";
7198 case ACTION_TELEPORT3:
7199 return "teleport_3_blocked_by";
7200 case ACTION_TELEPORT_CONQUER:
7201 return "teleport_conquer_blocked_by";
7202 case ACTION_TELEPORT_FRIGHTEN:
7203 return "teleport_frighten_blocked_by";
7204 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
7205 return "teleport_frighten_conquer_blocked_by";
7206 case ACTION_TELEPORT_ENTER:
7207 return "teleport_enter_blocked_by";
7208 case ACTION_TELEPORT_ENTER_CONQUER:
7209 return "teleport_enter_conquer_blocked_by";
7210 case ACTION_SPY_ESCAPE:
7211 case ACTION_SPY_POISON:
7212 case ACTION_SPY_POISON_ESC:
7213 case ACTION_SPY_SABOTAGE_UNIT:
7214 case ACTION_SPY_SABOTAGE_UNIT_ESC:
7215 case ACTION_SPY_BRIBE_UNIT:
7216 case ACTION_SPY_BRIBE_STACK:
7217 case ACTION_SPY_SABOTAGE_CITY:
7218 case ACTION_SPY_SABOTAGE_CITY_ESC:
7219 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
7220 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
7221 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
7222 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
7223 case ACTION_SPY_INCITE_CITY:
7224 case ACTION_SPY_INCITE_CITY_ESC:
7225 case ACTION_ESTABLISH_EMBASSY:
7226 case ACTION_ESTABLISH_EMBASSY_STAY:
7227 case ACTION_SPY_STEAL_TECH:
7228 case ACTION_SPY_STEAL_TECH_ESC:
7229 case ACTION_SPY_TARGETED_STEAL_TECH:
7230 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
7231 case ACTION_SPY_INVESTIGATE_CITY:
7232 case ACTION_INV_CITY_SPEND:
7233 case ACTION_SPY_STEAL_GOLD:
7234 case ACTION_SPY_STEAL_GOLD_ESC:
7235 case ACTION_STEAL_MAPS:
7236 case ACTION_STEAL_MAPS_ESC:
7237 case ACTION_TRADE_ROUTE:
7238 case ACTION_HELP_WONDER:
7239 case ACTION_CAPTURE_UNITS:
7240 case ACTION_EXPEL_UNIT:
7241 case ACTION_FOUND_CITY:
7242 case ACTION_JOIN_CITY:
7243 case ACTION_SPY_NUKE:
7244 case ACTION_SPY_NUKE_ESC:
7245 case ACTION_DESTROY_CITY:
7246 case ACTION_DISBAND_UNIT_RECOVER:
7247 case ACTION_DISBAND_UNIT:
7248 case ACTION_HOME_CITY:
7249 case ACTION_HOMELESS:
7250 case ACTION_UPGRADE_UNIT:
7251 case ACTION_PARADROP:
7252 case ACTION_PARADROP_CONQUER:
7253 case ACTION_PARADROP_FRIGHTEN:
7254 case ACTION_PARADROP_FRIGHTEN_CONQUER:
7255 case ACTION_PARADROP_ENTER:
7256 case ACTION_PARADROP_ENTER_CONQUER:
7257 case ACTION_AIRLIFT:
7258 case ACTION_STRIKE_BUILDING:
7259 case ACTION_STRIKE_PRODUCTION:
7260 case ACTION_HEAL_UNIT:
7261 case ACTION_HEAL_UNIT2:
7262 case ACTION_TRANSFORM_TERRAIN:
7263 case ACTION_TRANSFORM_TERRAIN2:
7264 case ACTION_CULTIVATE:
7265 case ACTION_CULTIVATE2:
7266 case ACTION_PLANT:
7267 case ACTION_PLANT2:
7268 case ACTION_PILLAGE:
7269 case ACTION_PILLAGE2:
7270 case ACTION_CLEAN:
7271 case ACTION_CLEAN2:
7272 case ACTION_FORTIFY:
7273 case ACTION_FORTIFY2:
7274 case ACTION_ROAD:
7275 case ACTION_ROAD2:
7276 case ACTION_CONVERT:
7277 case ACTION_BASE:
7278 case ACTION_BASE2:
7279 case ACTION_MINE:
7280 case ACTION_MINE2:
7281 case ACTION_IRRIGATE:
7282 case ACTION_IRRIGATE2:
7283 case ACTION_TRANSPORT_DEBOARD:
7284 case ACTION_TRANSPORT_BOARD:
7285 case ACTION_TRANSPORT_BOARD2:
7286 case ACTION_TRANSPORT_BOARD3:
7287 case ACTION_TRANSPORT_EMBARK:
7288 case ACTION_TRANSPORT_EMBARK2:
7289 case ACTION_TRANSPORT_EMBARK3:
7290 case ACTION_TRANSPORT_EMBARK4:
7291 case ACTION_TRANSPORT_UNLOAD:
7292 case ACTION_TRANSPORT_LOAD:
7293 case ACTION_TRANSPORT_LOAD2:
7294 case ACTION_TRANSPORT_LOAD3:
7295 case ACTION_TRANSPORT_DISEMBARK1:
7296 case ACTION_TRANSPORT_DISEMBARK2:
7297 case ACTION_TRANSPORT_DISEMBARK3:
7298 case ACTION_TRANSPORT_DISEMBARK4:
7299 case ACTION_SPY_SPREAD_PLAGUE:
7300 case ACTION_SPY_ATTACK:
7301 case ACTION_CONQUER_EXTRAS:
7302 case ACTION_CONQUER_EXTRAS2:
7303 case ACTION_CONQUER_EXTRAS3:
7304 case ACTION_CONQUER_EXTRAS4:
7305 case ACTION_HUT_ENTER:
7306 case ACTION_HUT_ENTER2:
7307 case ACTION_HUT_ENTER3:
7308 case ACTION_HUT_ENTER4:
7309 case ACTION_HUT_FRIGHTEN:
7310 case ACTION_HUT_FRIGHTEN2:
7311 case ACTION_HUT_FRIGHTEN3:
7312 case ACTION_HUT_FRIGHTEN4:
7313 case ACTION_SCOUT:
7314 case ACTION_GAIN_VETERANCY:
7315 case ACTION_CIVIL_WAR:
7316 case ACTION_FINISH_UNIT:
7317 case ACTION_FINISH_BUILDING:
7318 case ACTION_ESCAPE:
7319 case ACTION_USER_ACTION1:
7320 case ACTION_USER_ACTION2:
7321 case ACTION_USER_ACTION3:
7322 case ACTION_USER_ACTION4:
7323 /* blocked_by is not ruleset changeable */
7324 return nullptr;
7325 case ACTION_COUNT:
7326 fc_assert_ret_val(action_number(act) != ACTION_COUNT, nullptr);
7327 break;
7328
7329 ASSERT_UNUSED_ACTION_CASES;
7330 }
7331
7332 return nullptr;
7333}
7334
7335/**********************************************************************/
7339const char *
7340action_post_success_forced_ruleset_var_name(const struct action *act)
7341{
7342 fc_assert_ret_val(act != nullptr, nullptr);
7343
7344 if (!(action_has_result(act, ACTRES_SPY_BRIBE_UNIT)
7345 || action_has_result(act, ACTRES_SPY_BRIBE_STACK)
7346 || action_has_result(act, ACTRES_ATTACK)
7347 || action_has_result(act, ACTRES_WIPE_UNITS)
7348 || action_has_result(act, ACTRES_COLLECT_RANSOM))) {
7349 /* No support in the action performer function */
7350 return nullptr;
7351 }
7352
7353 switch ((enum gen_action)action_number(act)) {
7354 case ACTION_SPY_BRIBE_UNIT:
7355 return "bribe_unit_post_success_forced_actions";
7356 case ACTION_SPY_BRIBE_STACK:
7357 return "bribe_stack_post_success_forced_actions";
7358 case ACTION_ATTACK:
7359 return "attack_post_success_forced_actions";
7360 case ACTION_ATTACK2:
7361 return "attack_2_post_success_forced_actions";
7362 case ACTION_WIPE_UNITS:
7363 return "wipe_units_post_success_forced_actions";
7364 case ACTION_COLLECT_RANSOM:
7365 return "collect_ransom_post_success_forced_actions";
7366 case ACTION_MARKETPLACE:
7367 case ACTION_BOMBARD:
7368 case ACTION_BOMBARD2:
7369 case ACTION_BOMBARD3:
7370 case ACTION_BOMBARD4:
7371 case ACTION_BOMBARD_LETHAL:
7372 case ACTION_BOMBARD_LETHAL2:
7373 case ACTION_NUKE:
7374 case ACTION_NUKE_CITY:
7375 case ACTION_NUKE_UNITS:
7376 case ACTION_SUICIDE_ATTACK:
7377 case ACTION_SUICIDE_ATTACK2:
7378 case ACTION_CONQUER_CITY_SHRINK:
7379 case ACTION_CONQUER_CITY_SHRINK2:
7380 case ACTION_CONQUER_CITY_SHRINK3:
7381 case ACTION_CONQUER_CITY_SHRINK4:
7382 case ACTION_SPY_POISON:
7383 case ACTION_SPY_POISON_ESC:
7384 case ACTION_SPY_SABOTAGE_UNIT:
7385 case ACTION_SPY_SABOTAGE_UNIT_ESC:
7386 case ACTION_SPY_SABOTAGE_CITY:
7387 case ACTION_SPY_SABOTAGE_CITY_ESC:
7388 case ACTION_SPY_TARGETED_SABOTAGE_CITY:
7389 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION:
7390 case ACTION_SPY_TARGETED_SABOTAGE_CITY_ESC:
7391 case ACTION_SPY_SABOTAGE_CITY_PRODUCTION_ESC:
7392 case ACTION_SPY_INCITE_CITY:
7393 case ACTION_SPY_INCITE_CITY_ESC:
7394 case ACTION_ESTABLISH_EMBASSY:
7395 case ACTION_ESTABLISH_EMBASSY_STAY:
7396 case ACTION_SPY_STEAL_TECH:
7397 case ACTION_SPY_STEAL_TECH_ESC:
7398 case ACTION_SPY_TARGETED_STEAL_TECH:
7399 case ACTION_SPY_TARGETED_STEAL_TECH_ESC:
7400 case ACTION_SPY_INVESTIGATE_CITY:
7401 case ACTION_INV_CITY_SPEND:
7402 case ACTION_SPY_STEAL_GOLD:
7403 case ACTION_SPY_STEAL_GOLD_ESC:
7404 case ACTION_STEAL_MAPS:
7405 case ACTION_STEAL_MAPS_ESC:
7406 case ACTION_TRADE_ROUTE:
7407 case ACTION_HELP_WONDER:
7408 case ACTION_CAPTURE_UNITS:
7409 case ACTION_EXPEL_UNIT:
7410 case ACTION_FOUND_CITY:
7411 case ACTION_JOIN_CITY:
7412 case ACTION_SPY_NUKE:
7413 case ACTION_SPY_NUKE_ESC:
7414 case ACTION_DESTROY_CITY:
7415 case ACTION_DISBAND_UNIT_RECOVER:
7416 case ACTION_DISBAND_UNIT:
7417 case ACTION_HOME_CITY:
7418 case ACTION_HOMELESS:
7419 case ACTION_UPGRADE_UNIT:
7420 case ACTION_PARADROP:
7421 case ACTION_PARADROP_CONQUER:
7422 case ACTION_PARADROP_FRIGHTEN:
7423 case ACTION_PARADROP_FRIGHTEN_CONQUER:
7424 case ACTION_PARADROP_ENTER:
7425 case ACTION_PARADROP_ENTER_CONQUER:
7426 case ACTION_AIRLIFT:
7427 case ACTION_STRIKE_BUILDING:
7428 case ACTION_STRIKE_PRODUCTION:
7429 case ACTION_HEAL_UNIT:
7430 case ACTION_HEAL_UNIT2:
7431 case ACTION_TRANSFORM_TERRAIN:
7432 case ACTION_TRANSFORM_TERRAIN2:
7433 case ACTION_CULTIVATE:
7434 case ACTION_CULTIVATE2:
7435 case ACTION_PLANT:
7436 case ACTION_PLANT2:
7437 case ACTION_PILLAGE:
7438 case ACTION_PILLAGE2:
7439 case ACTION_CLEAN:
7440 case ACTION_CLEAN2:
7441 case ACTION_FORTIFY:
7442 case ACTION_FORTIFY2:
7443 case ACTION_ROAD:
7444 case ACTION_ROAD2:
7445 case ACTION_CONVERT:
7446 case ACTION_BASE:
7447 case ACTION_BASE2:
7448 case ACTION_MINE:
7449 case ACTION_MINE2:
7450 case ACTION_IRRIGATE:
7451 case ACTION_IRRIGATE2:
7452 case ACTION_TRANSPORT_DEBOARD:
7453 case ACTION_TRANSPORT_BOARD:
7454 case ACTION_TRANSPORT_BOARD2:
7455 case ACTION_TRANSPORT_BOARD3:
7456 case ACTION_TRANSPORT_EMBARK:
7457 case ACTION_TRANSPORT_EMBARK2:
7458 case ACTION_TRANSPORT_EMBARK3:
7459 case ACTION_TRANSPORT_EMBARK4:
7460 case ACTION_TRANSPORT_UNLOAD:
7461 case ACTION_TRANSPORT_LOAD:
7462 case ACTION_TRANSPORT_LOAD2:
7463 case ACTION_TRANSPORT_LOAD3:
7464 case ACTION_TRANSPORT_DISEMBARK1:
7465 case ACTION_TRANSPORT_DISEMBARK2:
7466 case ACTION_TRANSPORT_DISEMBARK3:
7467 case ACTION_TRANSPORT_DISEMBARK4:
7468 case ACTION_SPY_SPREAD_PLAGUE:
7469 case ACTION_SPY_ATTACK:
7470 case ACTION_CONQUER_EXTRAS:
7471 case ACTION_CONQUER_EXTRAS2:
7472 case ACTION_CONQUER_EXTRAS3:
7473 case ACTION_CONQUER_EXTRAS4:
7474 case ACTION_HUT_ENTER:
7475 case ACTION_HUT_ENTER2:
7476 case ACTION_HUT_ENTER3:
7477 case ACTION_HUT_ENTER4:
7478 case ACTION_HUT_FRIGHTEN:
7479 case ACTION_HUT_FRIGHTEN2:
7480 case ACTION_HUT_FRIGHTEN3:
7481 case ACTION_HUT_FRIGHTEN4:
7482 case ACTION_UNIT_MOVE:
7483 case ACTION_UNIT_MOVE2:
7484 case ACTION_UNIT_MOVE3:
7485 case ACTION_TELEPORT:
7486 case ACTION_TELEPORT2:
7487 case ACTION_TELEPORT3:
7488 case ACTION_TELEPORT_CONQUER:
7489 case ACTION_TELEPORT_FRIGHTEN:
7490 case ACTION_TELEPORT_FRIGHTEN_CONQUER:
7491 case ACTION_TELEPORT_ENTER:
7492 case ACTION_TELEPORT_ENTER_CONQUER:
7493 case ACTION_SPY_ESCAPE:
7494 case ACTION_SCOUT:
7495 case ACTION_GAIN_VETERANCY:
7496 case ACTION_ESCAPE:
7497 case ACTION_CIVIL_WAR:
7498 case ACTION_FINISH_UNIT:
7499 case ACTION_FINISH_BUILDING:
7500 case ACTION_USER_ACTION1:
7501 case ACTION_USER_ACTION2:
7502 case ACTION_USER_ACTION3:
7503 case ACTION_USER_ACTION4:
7504 /* Not ruleset changeable */
7505 return nullptr;
7506 case ACTION_COUNT:
7507 fc_assert_ret_val(action_number(act) != ACTION_COUNT, nullptr);
7508 break;
7509
7510 ASSERT_UNUSED_ACTION_CASES;
7511 }
7512
7513 return nullptr;
7514}
7515
7516/**********************************************************************/
7524
7525/**********************************************************************/
7528const char *gen_action_name_update_cb(const char *old_name)
7529{
7530 if (is_ruleset_compat_mode()) {
7531 }
7532
7533 return old_name;
7534}
7535
7536const char *atk_helpnames[ATK_COUNT] =
7537{
7538 N_("individual cities"), /* ATK_CITY */
7539 N_("individual units"), /* ATK_UNIT */
7540 N_("unit stacks"), /* ATK_STACK */
7541 N_("tiles"), /* ATK_TILE */
7542 N_("tile extras"), /* ATK_EXTRAS */
7543 N_("itself") /* ATK_SELF */
7544};
7545
7546/**********************************************************************/
7550const char *action_target_kind_help(enum action_target_kind kind)
7551{
7552 fc_assert(kind >= 0 && kind < ATK_COUNT);
7553
7554 return _(atk_helpnames[kind]);
7555}
7556
7557/************************************************************************/
7560struct action_list *action_list_by_result(enum action_result result)
7561{
7562 fc_assert(result < ACTRES_LAST);
7563
7564 return actlist_by_result[result];
7565}
7566
7567/************************************************************************/
7570struct action_list *action_list_by_activity(enum unit_activity activity)
7571{
7572 fc_assert(activity < ACTIVITY_LAST);
7573
7574 return actlist_by_activity[activity];
7575}
7576
7577/************************************************************************/
7581enum gen_action select_actres_action_unit_on_stack(struct civ_map *nmap,
7582 enum action_result actres,
7583 struct unit *punit,
7584 struct tile *ptile)
7585{
7586 if (actres >= ACTRES_LAST) {
7587 return ACTION_NONE;
7588 }
7589
7590 action_list_iterate(action_list_by_result(actres), paction) {
7591 enum gen_action act = action_number(paction);
7592
7593 if (is_action_enabled_unit_on_stack(nmap, act, punit, ptile)) {
7594 return act;
7595 }
7596 } action_list_iterate_end;
7597
7598 return ACTION_NONE;
7599}
7600
7601/************************************************************************/
7605enum gen_action select_actres_action_unit_on_tile(struct civ_map *nmap,
7606 enum action_result actres,
7607 struct unit *punit,
7608 struct tile *ptile)
7609{
7610 if (actres >= ACTRES_LAST) {
7611 return ACTION_NONE;
7612 }
7613
7614 action_list_iterate(action_list_by_result(actres), paction) {
7615 enum gen_action act = action_number(paction);
7616
7617 if (action_id_get_target_kind(act) == ATK_TILE
7618 && is_action_enabled_unit_on_tile(nmap, act, punit, ptile, nullptr)) {
7619 return act;
7620 }
7621 } action_list_iterate_end;
7622
7623 return ACTION_NONE;
7624}
7625
7626/************************************************************************/
7630enum gen_action select_actres_action_unit_on_city(struct civ_map *nmap,
7631 enum action_result actres,
7632 struct unit *punit,
7633 struct city *pcity)
7634{
7635 if (actres >= ACTRES_LAST) {
7636 return ACTION_NONE;
7637 }
7638
7639 action_list_iterate(action_list_by_result(actres), paction) {
7640 enum gen_action act = action_number(paction);
7641
7642 if (action_id_get_target_kind(act) == ATK_CITY
7643 && is_action_enabled_unit_on_city(nmap, act, punit, pcity)) {
7644 return act;
7645 }
7646 } action_list_iterate_end;
7647
7648 return ACTION_NONE;
7649}
is_action_possible_on_city
bool is_action_possible_on_city(action_id act_id, const struct player *actor_player, const struct city *target_city)
Definition actions.c:5727
actions
static struct action * actions[MAX_NUM_ACTIONS]
Definition actions.c:57
action_prepare_ui_name
const char * action_prepare_ui_name(action_id act_id, const char *mnemonic, const struct act_prob prob, const char *custom)
Definition actions.c:1338
action_distance_inside_max
bool action_distance_inside_max(const struct action *action, const int distance)
Definition actions.c:1199
action_speculate_unit_on_extras
struct act_prob action_speculate_unit_on_extras(const struct civ_map *nmap, action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, bool omniscient_cheat, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:5215
is_action_possible
static enum fc_tristate is_action_possible(const struct civ_map *nmap, const action_id wanted_action, const struct req_context *actor, const struct req_context *target, const struct extra_type *target_extra, const bool omniscient, const struct city *homecity)
Definition actions.c:2819
action_prob_explain
const char * action_prob_explain(const struct act_prob prob)
Definition actions.c:1449
action_mp_full_makes_legal
bool action_mp_full_makes_legal(const struct unit *actor, const action_id act_id)
Definition actions.c:5805
action_prob_battle_then_dice_roll
static struct act_prob action_prob_battle_then_dice_roll(const struct player *act_player, const struct unit *act_unit, const struct city *tgt_city, const struct unit *tgt_unit, const struct tile *tgt_tile, const struct player *tgt_player, const struct action *paction)
Definition actions.c:4030
is_action_enabled_unit_on_self_full
static bool is_action_enabled_unit_on_self_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile)
Definition actions.c:3448
action_get_actor_kind
enum action_actor_kind action_get_actor_kind(const struct action *paction)
Definition actions.c:1124
action_prob_certain
bool action_prob_certain(const struct act_prob probability)
Definition actions.c:5337
action_id_name_translation
const char * action_id_name_translation(action_id act_id)
Definition actions.c:1276
action_auto_perf_slot_number
struct action_auto_perf * action_auto_perf_slot_number(const int num)
Definition actions.c:5966
action_enabler_vector_number
req_vec_num_in_item action_enabler_vector_number(const void *enabler, const struct requirement_vector *vec)
Definition actions.c:2053
action_has_complex_target
bool action_has_complex_target(const struct action *paction)
Definition actions.c:1158
action_actor_utype_hard_reqs_ok_full
static bool action_actor_utype_hard_reqs_ok_full(const struct action *paction, const struct unit_type *actor_unittype, bool ignore_third_party)
Definition actions.c:2402
ASSERT_PLAYER_ACTION
#define ASSERT_PLAYER_ACTION(_atk)
Definition actions.c:3509
action_enabler_suggest_repair
struct req_vec_problem * action_enabler_suggest_repair(const struct action_enabler *enabler)
Definition actions.c:1923
is_action_enabled_unit_on_tile_full
static bool is_action_enabled_unit_on_tile_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3293
action_prob_possible
bool action_prob_possible(const struct act_prob probability)
Definition actions.c:5327
ACTPROB_VAL_NOT_IMPL
#define ACTPROB_VAL_NOT_IMPL
Definition actions.c:55
auto_perfs
struct action_auto_perf auto_perfs[MAX_NUM_ACTION_AUTO_PERFORMERS]
Definition actions.c:59
action_actor_utype_hard_reqs_ok
bool action_actor_utype_hard_reqs_ok(const struct action *paction, const struct unit_type *actor_unittype)
Definition actions.c:2611
action_prob_new_not_impl
struct act_prob action_prob_new_not_impl(void)
Definition actions.c:5306
action_enabler_suggest_improvement
struct req_vec_problem * action_enabler_suggest_improvement(const struct action_enabler *enabler)
Definition actions.c:1989
action_enabled_local
static enum fc_tristate action_enabled_local(const action_id wanted_action, const struct req_context *actor, const struct req_context *target)
Definition actions.c:3757
action_speculate_unit_on_stack
struct act_prob action_speculate_unit_on_stack(const struct civ_map *nmap, action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, bool omniscient_cheat, const struct tile *target)
Definition actions.c:5148
actions_rs_pre_san_gen
void actions_rs_pre_san_gen(void)
Definition actions.c:904
action_min_range_ruleset_var_name
const char * action_min_range_ruleset_var_name(int act)
Definition actions.c:6420
action_speculate_unit_on_self
struct act_prob action_speculate_unit_on_self(const struct civ_map *nmap, action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, bool omniscient_cheat)
Definition actions.c:5249
is_effect_val_known
static bool is_effect_val_known(enum effect_type effect_type, const struct player *pov_player, const struct req_context *context, const struct req_context *other_context)
Definition actions.c:3804
action_blocked_by_ruleset_var_name
const char * action_blocked_by_ruleset_var_name(const struct action *act)
Definition actions.c:7143
is_action_enabled
static bool is_action_enabled(const struct civ_map *nmap, const action_id wanted_action, const struct req_context *actor, const struct req_context *target, const struct extra_type *target_extra, const struct city *actor_home)
Definition actions.c:2995
ACTPROB_VAL_MAX
#define ACTPROB_VAL_MAX
Definition actions.c:49
action_prob
static struct act_prob action_prob(const struct civ_map *nmap, const action_id wanted_action, const struct req_context *actor, const struct city *actor_home, const struct req_context *target, const struct extra_type *target_extra)
Definition actions.c:4078
action_enabler_suggest_repair_oblig
struct req_vec_problem * action_enabler_suggest_repair_oblig(const struct action_enabler *enabler)
Definition actions.c:1709
action_array_add_all_by_result
void action_array_add_all_by_result(action_id *act_array, int *position, enum action_result result)
Definition actions.c:6031
action_name_translation
const char * action_name_translation(const struct action *paction)
Definition actions.c:1256
action_dice_roll_odds
int action_dice_roll_odds(const struct player *act_player, const struct unit *act_unit, const struct city *tgt_city, const struct player *tgt_player, const struct action *paction)
Definition actions.c:5627
action_array_end
void action_array_end(action_id *act_array, int size)
Definition actions.c:6014
action_prob_vs_tile
struct act_prob action_prob_vs_tile(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:4848
action_prob_pre_action_dice_roll
static struct act_prob action_prob_pre_action_dice_roll(const struct player *act_player, const struct unit *act_unit, const struct city *tgt_city, const struct player *tgt_player, const struct action *paction)
Definition actions.c:3982
atk_helpnames
const char * atk_helpnames[ATK_COUNT]
Definition actions.c:7536
action_hard_reqs_actor
static enum fc_tristate action_hard_reqs_actor(const struct civ_map *nmap, const struct action *paction, const struct req_context *actor, const bool omniscient, const struct city *homecity)
Definition actions.c:2631
hard_code_actions
static void hard_code_actions(void)
Definition actions.c:110
is_action_enabled_unit_on_city_full
static bool is_action_enabled_unit_on_city_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const struct city *target_city)
Definition actions.c:3045
action_is_in_use
bool action_is_in_use(struct action *paction)
Definition actions.c:5920
enabler_tile_tgt_local_diplrel_implies_claimed
static struct req_vec_problem * enabler_tile_tgt_local_diplrel_implies_claimed(const struct action_enabler *enabler)
Definition actions.c:1778
action_ever_possible
bool action_ever_possible(action_id action)
Definition actions.c:7520
action_enabler_vector_by_number_name
const char * action_enabler_vector_by_number_name(req_vec_num_in_item vec)
Definition actions.c:2100
are_action_probabilitys_equal
bool are_action_probabilitys_equal(const struct act_prob *ap1, const struct act_prob *ap2)
Definition actions.c:5378
is_action_enabled_player_on_tile
bool is_action_enabled_player_on_tile(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3664
action_prob_self_full
static struct act_prob action_prob_self_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id)
Definition actions.c:4948
action_post_success_forced_ruleset_var_name
const char * action_post_success_forced_ruleset_var_name(const struct action *act)
Definition actions.c:7340
action_by_rule_name
struct action * action_by_rule_name(const char *name)
Definition actions.c:1105
action_has_possible_actor_hard_reqs
static bool action_has_possible_actor_hard_reqs(struct action *paction)
Definition actions.c:5890
select_actres_action_unit_on_stack
enum gen_action select_actres_action_unit_on_stack(struct civ_map *nmap, enum action_result actres, struct unit *punit, struct tile *ptile)
Definition actions.c:7581
action_new
static struct action * action_new(action_id id, enum action_actor_kind aak, enum action_result result, const int min_distance, const int max_distance, bool actor_consuming_always)
Definition actions.c:980
action_rule_name
const char * action_rule_name(const struct action *action)
Definition actions.c:1242
action_id_rule_name
const char * action_id_rule_name(action_id act_id)
Definition actions.c:1265
action_get_sub_target_kind
enum action_sub_target_kind action_get_sub_target_kind(const struct action *paction)
Definition actions.c:1145
blocked_find_target_tile
static const struct tile * blocked_find_target_tile(const struct action *act, const struct unit *actor_unit, const struct tile *target_tile_arg, const struct city *target_city, const struct unit *target_unit)
Definition actions.c:2168
action_prob_not_relevant
static bool action_prob_not_relevant(const struct act_prob probability)
Definition actions.c:5348
ap_diplomat_battle
static struct act_prob ap_diplomat_battle(const struct unit *pattacker, const struct unit *pvictim, const struct tile *tgt_tile, const struct action *paction) fc__attribute((nonnull(3)))
Definition actions.c:3936
actions_free
void actions_free(void)
Definition actions.c:914
is_action_enabled_unit_on_extras_full
static bool is_action_enabled_unit_on_extras_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3370
action_enabler_free
void action_enabler_free(struct action_enabler *enabler)
Definition actions.c:1521
is_action_enabled_unit_on_stack
bool is_action_enabled_unit_on_stack(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct tile *target_tile)
Definition actions.c:3275
tech_can_be_stolen
static enum fc_tristate tech_can_be_stolen(const struct player *actor_player, const struct player *target_player)
Definition actions.c:3823
actlist_by_result
static struct action_list * actlist_by_result[ACTRES_LAST]
Definition actions.c:103
action_list_by_activity
struct action_list * action_list_by_activity(enum unit_activity activity)
Definition actions.c:7570
action_number
int action_number(const struct action *action)
Definition actions.c:1234
action_prob_new_unknown
struct act_prob action_prob_new_unknown(void)
Definition actions.c:5316
action_would_be_blocked_by
bool action_would_be_blocked_by(const struct action *blocked, const struct action *blocker)
Definition actions.c:1222
ACTPROB_VAL_NA
#define ACTPROB_VAL_NA
Definition actions.c:53
player_action_new
static struct action * player_action_new(action_id id, enum action_result result)
Definition actions.c:1070
enabler_first_clarification
static struct req_vec_problem * enabler_first_clarification(const struct action_enabler *enabler)
Definition actions.c:1971
action_prob_not_impl
static bool action_prob_not_impl(const struct act_prob probability)
Definition actions.c:5359
is_action_enabled_unit_on_tile
bool is_action_enabled_unit_on_tile(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3351
action_prob_and
struct act_prob action_prob_and(const struct act_prob *ap1, const struct act_prob *ap2)
Definition actions.c:5465
actions_initialized
static bool actions_initialized
Definition actions.c:60
action_actor_consuming_always_ruleset_var_name
const char * action_actor_consuming_always_ruleset_var_name(action_id act)
Definition actions.c:6967
action_immune_government
bool action_immune_government(struct government *gov, action_id act)
Definition actions.c:5683
is_target_possible
static bool is_target_possible(const action_id wanted_action, const struct player *actor_player, const struct req_context *target)
Definition actions.c:5706
city_action_new
static struct action * city_action_new(action_id id, enum action_result result)
Definition actions.c:1082
ap_dipl_battle_win
static struct act_prob ap_dipl_battle_win(const struct unit *pattacker, const struct unit *pdefender)
Definition actions.c:3859
action_prob_vs_stack_full
static struct act_prob action_prob_vs_stack_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id, const struct tile *target_tile)
Definition actions.c:4590
action_prob_vs_extras
struct act_prob action_prob_vs_extras(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:4931
action_prob_new_certain
struct act_prob action_prob_new_certain(void)
Definition actions.c:5286
action_max_range_ruleset_var_name
const char * action_max_range_ruleset_var_name(int act)
Definition actions.c:6601
action_prob_vs_city_full
static struct act_prob action_prob_vs_city_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id, const struct city *target_city)
Definition actions.c:4403
action_is_internal
bool action_is_internal(struct action *paction)
Definition actions.c:5946
action_dice_roll_initial_odds
int action_dice_roll_initial_odds(const struct action *paction)
Definition actions.c:5603
action_prob_self
struct act_prob action_prob_self(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id)
Definition actions.c:5001
action_prob_fall_back
struct act_prob action_prob_fall_back(const struct act_prob *ap1, const struct act_prob *ap2)
Definition actions.c:5535
tgt_city_local_utype
static const struct unit_type * tgt_city_local_utype(const struct city *target_city)
Definition actions.c:2143
is_action_enabled_city
bool is_action_enabled_city(const struct civ_map *nmap, const action_id wanted_action, const struct city *actor_city)
Definition actions.c:3725
is_action_enabled_player_on_stack
bool is_action_enabled_player_on_stack(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3619
req_vec_first_local_diplrel
static struct requirement * req_vec_first_local_diplrel(const struct requirement_vector *vec)
Definition actions.c:1759
action_prob_vs_tile_full
static struct act_prob action_prob_vs_tile_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:4782
is_action_enabled_player_on_city
bool is_action_enabled_player_on_city(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr, const struct city *target_city)
Definition actions.c:3550
is_action_enabled_unit_on_city
bool is_action_enabled_unit_on_city(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *target_city)
Definition actions.c:3110
select_actres_action_unit_on_tile
enum gen_action select_actres_action_unit_on_tile(struct civ_map *nmap, enum action_result actres, struct unit *punit, struct tile *ptile)
Definition actions.c:7605
action_list_by_result
struct action_list * action_list_by_result(enum action_result result)
Definition actions.c:7560
is_action_enabled_player_on_self
bool is_action_enabled_player_on_self(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr)
Definition actions.c:3528
action_univs_not_blocking
bool action_univs_not_blocking(const struct action *paction, struct universal *actor_uni, struct universal *target_uni)
Definition actions.c:5990
action_speculate_unit_on_city
struct act_prob action_speculate_unit_on_city(const struct civ_map *nmap, const action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, const bool omniscient_cheat, const struct city *target)
Definition actions.c:5080
actions_are_ready
bool actions_are_ready(void)
Definition actions.c:956
is_action_enabled_unit_on_unit
bool is_action_enabled_unit_on_unit(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct unit *target_unit)
Definition actions.c:3187
action_speculate_unit_on_tile
struct act_prob action_speculate_unit_on_tile(const struct civ_map *nmap, action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, bool omniscient_cheat, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:5181
action_prob_vs_city
struct act_prob action_prob_vs_city(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id, const struct city *target_city)
Definition actions.c:4490
action_target_kind_ruleset_var_name
const char * action_target_kind_ruleset_var_name(int act)
Definition actions.c:6792
action_prob_vs_unit_full
static struct act_prob action_prob_vs_unit_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id, const struct unit *target_unit)
Definition actions.c:4506
action_maybe_possible_actor_unit
bool action_maybe_possible_actor_unit(const struct civ_map *nmap, const action_id act_id, const struct unit *actor_unit)
Definition actions.c:5750
action_is_blocked_by
struct action * action_is_blocked_by(const struct civ_map *nmap, const struct action *act, const struct unit *actor_unit, const struct tile *target_tile_arg, const struct city *target_city_arg, const struct unit *target_unit)
Definition actions.c:2287
is_enabler_active
static bool is_enabler_active(const struct action_enabler *enabler, const struct req_context *actor, const struct req_context *target)
Definition actions.c:2978
action_enablers_by_action
static struct action_enabler_list * action_enablers_by_action[MAX_NUM_ACTIONS]
Definition actions.c:62
action_enabler_add
void action_enabler_add(struct action_enabler *enabler)
Definition actions.c:1552
is_action_enabled_player_on_extras
bool is_action_enabled_player_on_extras(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3588
is_action_enabled_player_on_unit
bool is_action_enabled_player_on_unit(const struct civ_map *nmap, const action_id wanted_action, const struct player *actor_plr, const struct unit *target_unit)
Definition actions.c:3695
action_ui_name_default
const char * action_ui_name_default(int act)
Definition actions.c:6049
action_enablers_allow
bool action_enablers_allow(const action_id wanted_action, const struct req_context *actor, const struct req_context *target)
Definition actions.c:3024
ACTPROB_VAL_1_PCT
#define ACTPROB_VAL_1_PCT
Definition actions.c:51
action_enabler_utype_possible_actor
bool action_enabler_utype_possible_actor(const struct action_enabler *ae, const struct unit_type *act_utype)
Definition actions.c:5828
act_prob_unseen_target
static struct act_prob act_prob_unseen_target(const struct civ_map *nmap, action_id act_id, const struct unit *actor_unit)
Definition actions.c:3964
action_enabler_new
struct action_enabler * action_enabler_new(void)
Definition actions.c:1501
action_requires_details
bool action_requires_details(const struct action *paction)
Definition actions.c:1171
action_prob_new_not_relevant
struct act_prob action_prob_new_not_relevant(void)
Definition actions.c:5296
action_target_kind_help
const char * action_target_kind_help(enum action_target_kind kind)
Definition actions.c:7550
enabler_first_self_contradiction
static struct req_vec_problem * enabler_first_self_contradiction(const struct action_enabler *enabler)
Definition actions.c:1851
action_get_role
int action_get_role(const struct action *paction)
Definition actions.c:1489
action_speculate_unit_on_unit
struct act_prob action_speculate_unit_on_unit(const struct civ_map *nmap, action_id act_id, const struct unit *actor, const struct city *actor_home, const struct tile *actor_tile, bool omniscient_cheat, const struct unit *target)
Definition actions.c:5115
unit_action_new
static struct action * unit_action_new(action_id id, enum action_result result, bool rare_pop_up, bool unitwaittime_controlled, enum moves_actor_kind moves_actor, const int min_distance, const int max_distance, bool actor_consuming_always)
Definition actions.c:1045
action_auto_perf_by_number
const struct action_auto_perf * action_auto_perf_by_number(const int num)
Definition actions.c:5982
action_prob_new_impossible
struct act_prob action_prob_new_impossible(void)
Definition actions.c:5276
action_enabler_possible_actor
bool action_enabler_possible_actor(const struct action_enabler *ae)
Definition actions.c:5855
blocked_find_target_city
static const struct city * blocked_find_target_city(const struct action *act, const struct unit *actor_unit, const struct tile *target_tile, const struct city *target_city_arg, const struct unit *target_unit)
Definition actions.c:2228
_actions
struct action ** _actions
Definition actions.c:58
action_id_exists
bool action_id_exists(const action_id act_id)
Definition actions.c:1094
action_enabler_remove
bool action_enabler_remove(struct action_enabler *enabler)
Definition actions.c:1569
action_get_target_kind
enum action_target_kind action_get_target_kind(const struct action *paction)
Definition actions.c:1134
action_prob_unit_vs_tgt
struct act_prob action_prob_unit_vs_tgt(const struct civ_map *nmap, const struct action *paction, const struct unit *act_unit, const struct city *tgt_city, const struct unit *tgt_unit, const struct tile *tgt_tile, const struct extra_type *extra_tgt)
Definition actions.c:5023
action_prob_is_signal
static bool action_prob_is_signal(const struct act_prob probability)
Definition actions.c:5370
action_enabler_copy
struct action_enabler * action_enabler_copy(const struct action_enabler *original)
Definition actions.c:1537
action_prob_to_text
static const char * action_prob_to_text(const struct act_prob prob)
Definition actions.c:1297
action_prob_cmp_pessimist
int action_prob_cmp_pessimist(const struct act_prob ap1, const struct act_prob ap2)
Definition actions.c:5387
action_prob_vs_stack
struct act_prob action_prob_vs_stack(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id, const struct tile *target_tile)
Definition actions.c:4765
action_id_is_internal
bool action_id_is_internal(action_id act)
Definition actions.c:5958
is_action_enabled_unit_on_self
bool is_action_enabled_unit_on_self(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit)
Definition actions.c:3500
action_id_is_rare_pop_up
bool action_id_is_rare_pop_up(action_id act_id)
Definition actions.c:1186
actions_init
void actions_init(void)
Definition actions.c:855
ae_suggest_repair_if_no_oblig
static struct req_vec_problem * ae_suggest_repair_if_no_oblig(const struct action_enabler *enabler, const struct obligatory_req_vector *oblig)
Definition actions.c:1605
action_prob_vs_unit
struct act_prob action_prob_vs_unit(const struct civ_map *nmap, const struct unit *actor_unit, const action_id act_id, const struct unit *target_unit)
Definition actions.c:4573
tgt_city_local_building
static const struct impr_type * tgt_city_local_building(const struct city *target_city)
Definition actions.c:2120
ui_name_str
static struct astring ui_name_str
Definition actions.c:64
is_action_enabled_unit_on_extras
bool is_action_enabled_unit_on_extras(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:3428
is_action_enabled_unit_on_unit_full
static bool is_action_enabled_unit_on_unit_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const struct unit *target_unit)
Definition actions.c:3128
is_action_enabled_unit_on_stack_full
static bool is_action_enabled_unit_on_stack_full(const struct civ_map *nmap, const action_id wanted_action, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const struct tile *target_tile)
Definition actions.c:3205
action_prob_to_0_to_1_pessimist
double action_prob_to_0_to_1_pessimist(const struct act_prob ap)
Definition actions.c:5438
gen_action_name_update_cb
const char * gen_action_name_update_cb(const char *old_name)
Definition actions.c:7528
select_actres_action_unit_on_city
enum gen_action select_actres_action_unit_on_city(struct civ_map *nmap, enum action_result actres, struct unit *punit, struct city *pcity)
Definition actions.c:7630
actlist_by_activity
static struct action_list * actlist_by_activity[ACTIVITY_LAST]
Definition actions.c:104
action_enablers_for_action
struct action_enabler_list * action_enablers_for_action(action_id action)
Definition actions.c:1585
action_enabler_vector_by_number
struct requirement_vector * action_enabler_vector_by_number(const void *enabler, req_vec_num_in_item number)
Definition actions.c:2076
action_distance_accepted
bool action_distance_accepted(const struct action *action, const int distance)
Definition actions.c:1210
action_prob_vs_extras_full
static struct act_prob action_prob_vs_extras_full(const struct civ_map *nmap, const struct unit *actor_unit, const struct city *actor_home, const struct tile *actor_tile, const action_id act_id, const struct tile *target_tile, const struct extra_type *target_extra)
Definition actions.c:4865
action_get_ui_name_mnemonic
const char * action_get_ui_name_mnemonic(action_id act_id, const char *mnemonic)
Definition actions.c:1284
ACTPROB_VAL_MIN
#define ACTPROB_VAL_MIN
Definition actions.c:47
action_list_iterate_end
#define action_list_iterate_end
Definition actions.h:229
action_noninternal_iterate_end
#define action_noninternal_iterate_end
Definition actions.h:240
ACTION_DISTANCE_MAX
#define ACTION_DISTANCE_MAX
Definition actions.h:107
enabler_get_action
#define enabler_get_action(_enabler_)
Definition actions.h:186
ASSERT_UNUSED_ACTION_CASES
#define ASSERT_UNUSED_ACTION_CASES
Definition actions.h:38
ACTPROB_CERTAIN
#define ACTPROB_CERTAIN
Definition actions.h:718
enabler_get_action_id
#define enabler_get_action_id(_enabler_)
Definition actions.h:187
ACTPROB_NA
#define ACTPROB_NA
Definition actions.h:719
action_by_number
static struct action * action_by_number(action_id act_id)
Definition actions.h:400
action_enabler_list_re_iterate_end
#define action_enabler_list_re_iterate_end
Definition actions.h:200
ACTION_DISTANCE_LAST_NON_SIGNAL
#define ACTION_DISTANCE_LAST_NON_SIGNAL
Definition actions.h:103
action_enabler_list_re_iterate
#define action_enabler_list_re_iterate(action_enabler_list, aenabler)
Definition actions.h:196
action_has_result
#define action_has_result(_act_, _res_)
Definition actions.h:184
action_enabler_list_iterate_end
#define action_enabler_list_iterate_end
Definition actions.h:194
ACTION_DISTANCE_UNLIMITED
#define ACTION_DISTANCE_UNLIMITED
Definition actions.h:105
action_iterate_end
#define action_iterate_end
Definition actions.h:218
MAX_NUM_ACTIONS
#define MAX_NUM_ACTIONS
Definition actions.h:62
action_iterate_all
#define action_iterate_all(_act_)
Definition actions.h:204
action_id_get_actor_kind
#define action_id_get_actor_kind(act_id)
Definition actions.h:413
action_iterate_all_end
#define action_iterate_all_end
Definition actions.h:209
ACTPROB_NOT_KNOWN
#define ACTPROB_NOT_KNOWN
Definition actions.h:721
action_enabler_list_iterate
#define action_enabler_list_iterate(action_enabler_list, aenabler)
Definition actions.h:192
action_id_distance_accepted
#define action_id_distance_accepted(act_id, distance)
Definition actions.h:449
ACTPROB_IMPOSSIBLE
#define ACTPROB_IMPOSSIBLE
Definition actions.h:717
ACTPROB_NOT_IMPLEMENTED
#define ACTPROB_NOT_IMPLEMENTED
Definition actions.h:720
action_iterate
#define action_iterate(_act_)
Definition actions.h:214
ACTION_ANY
#define ACTION_ANY
Definition actions.h:56
action_noninternal_iterate
#define action_noninternal_iterate(_act_)
Definition actions.h:235
action_list_iterate
#define action_list_iterate(_list_, _act_)
Definition actions.h:227
action_id_get_target_kind
#define action_id_get_target_kind(act_id)
Definition actions.h:417
action_id_has_result_safe
#define action_id_has_result_safe(act_id, result)
Definition actions.h:430
ACTION_ODDS_PCT_DICE_ROLL_NA
#define ACTION_ODDS_PCT_DICE_ROLL_NA
Definition actions.h:724
ACTION_NONE
#define ACTION_NONE
Definition actions.h:59
actres_sub_target_kind_default
enum action_sub_target_kind actres_sub_target_kind_default(enum action_result result)
Definition actres.c:679
actres_target_compl_calc
enum act_tgt_compl actres_target_compl_calc(enum action_result result)
Definition actres.c:262
actres_possible
enum fc_tristate actres_possible(const struct civ_map *nmap, enum action_result result, const struct req_context *actor, const struct req_context *target, const struct extra_type *target_extra, enum fc_tristate def, bool omniscient, const struct city *homecity)
Definition actres.c:843
actres_activity_result
enum unit_activity actres_activity_result(enum action_result result)
Definition actres.c:305
actres_dice_type
enum dice_roll_type actres_dice_type(enum action_result result)
Definition actres.c:368
actres_get_battle_kind
enum action_battle_kind actres_get_battle_kind(enum action_result result)
Definition actres.c:276
actres_target_kind_default
enum action_target_kind actres_target_kind_default(enum action_result result)
Definition actres.c:778
ASSERT_UNUSED_ACTRES_CASES
#define ASSERT_UNUSED_ACTRES_CASES
Definition actres.h:37
DRT_DIPLCHANCE
@ DRT_DIPLCHANCE
Definition actres.h:109
DRT_CERTAIN
@ DRT_CERTAIN
Definition actres.h:109
DRT_NONE
@ DRT_NONE
Definition actres.h:109
astr_free
void astr_free(struct astring *astr)
Definition astring.c:148
astr_set
void astr_set(struct astring *astr, const char *format,...)
Definition astring.c:251
astr_clear
void astr_clear(struct astring *astr)
Definition astring.c:201
astr_add
void astr_add(struct astring *astr, const char *format,...)
Definition astring.c:271
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
territory_claiming_base
bool territory_claiming_base(const struct base_type *pbase)
Definition base.c:163
BV_CLR_ALL
#define BV_CLR_ALL(bv)
Definition bitvector.h:103
BV_ISSET
#define BV_ISSET(bv, bit)
Definition bitvector.h:86
is_non_attack_city_tile
static bool is_non_attack_city_tile(const struct tile *ptile, const struct player *pplayer)
Definition city.h:766
city_tile
#define city_tile(_pcity_)
Definition city.h:565
city_owner
#define city_owner(_pcity_)
Definition city.h:564
unit_win_chance
double unit_win_chance(const struct civ_map *nmap, const struct unit *attacker, const struct unit *defender, const struct action *paction)
Definition combat.c:480
unit_attack_units_at_tile_result
enum unit_attack_result unit_attack_units_at_tile_result(const struct unit *punit, const struct action *paction, const struct tile *ptile)
Definition combat.c:257
get_defender
struct unit * get_defender(const struct civ_map *nmap, const struct unit *attacker, const struct tile *ptile, const struct action *paction)
Definition combat.c:841
get_diplomatic_defender
struct unit * get_diplomatic_defender(const struct unit *act_unit, const struct unit *pvictim, const struct tile *tgt_tile, const struct action *paction)
Definition combat.c:947
can_unit_attack_tile
bool can_unit_attack_tile(const struct unit *punit, const struct action *paction, const struct tile *dest_tile)
Definition combat.c:312
ATT_OK
@ ATT_OK
Definition combat.h:35
enablers
char * enablers
Definition comments.c:59
incite_cost
char * incite_cost
Definition comments.c:77
target_unit
struct unit struct city struct unit * target_unit
Definition dialogs_g.h:55
actor
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit * actor
Definition dialogs_g.h:72
actor_unit
struct unit * actor_unit
Definition dialogs_g.h:54
target_tile
struct unit struct city struct unit struct tile * target_tile
Definition dialogs_g.h:56
punit
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:73
pcity
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit int const struct action *paction struct unit struct city * pcity
Definition dialogs_g.h:77
target_city
struct unit struct city * target_city
Definition dialogs_g.h:55
target_extra
struct unit struct city struct unit struct tile struct extra_type * target_extra
Definition dialogs_g.h:56
id
int int id
Definition editgui_g.h:28
reqs
struct @22::@23 reqs
get_target_bonus_effects
int get_target_bonus_effects(struct effect_list *plist, const struct req_context *context, const struct req_context *other_context, enum effect_type effect_type)
Definition effects.c:744
get_effects
struct effect_list * get_effects(enum effect_type effect_type)
Definition effects.c:143
effect_list_iterate_end
#define effect_list_iterate_end
Definition effects.h:81
effect_list_iterate
#define effect_list_iterate(effect_list, peffect)
Definition effects.h:79
extra_type_list_of_terr_claimers
struct extra_type_list * extra_type_list_of_terr_claimers(void)
Definition extras.c:275
is_native_extra_to_uclass
bool is_native_extra_to_uclass(const struct extra_type *pextra, const struct unit_class *pclass)
Definition extras.c:857
extra_type_list_iterate
#define extra_type_list_iterate(extralist, pextra)
Definition extras.h:165
extra_type_list_iterate_end
#define extra_type_list_iterate_end
Definition extras.h:167
fc_funcs
const struct functions * fc_funcs
Definition fc_interface.c:38
fc_interface.h
Tech_type_id
int Tech_type_id
Definition fc_types.h:238
RPT_CERTAIN
@ RPT_CERTAIN
Definition fc_types.h:516
RPT_POSSIBLE
@ RPT_POSSIBLE
Definition fc_types.h:515
action_id
int action_id
Definition fc_types.h:250
ACTRES_NONE
#define ACTRES_NONE
Definition fc_types.h:188
MAX_NUM_ACTION_AUTO_PERFORMERS
#define MAX_NUM_ACTION_AUTO_PERFORMERS
Definition fc_types.h:54
_
#define _(String)
Definition fcintl.h:67
N_
#define N_(String)
Definition fcintl.h:69
game
struct civ_game game
Definition game.c:62
is_ruleset_compat_mode
static bool is_ruleset_compat_mode(void)
Definition game.h:370
name
const char * name
Definition inputfile.c:127
fc_assert_msg
#define fc_assert_msg(condition, message,...)
Definition log.h:182
fc_assert_ret
#define fc_assert_ret(condition)
Definition log.h:192
log_verbose
#define log_verbose(message,...)
Definition log.h:110
fc_assert
#define fc_assert(condition)
Definition log.h:177
fc_assert_action_msg
#define fc_assert_action_msg(condition, action, message,...)
Definition log.h:202
fc_assert_ret_val
#define fc_assert_ret_val(condition, val)
Definition log.h:195
fc_assert_action
#define fc_assert_action(condition, action)
Definition log.h:188
log_error
#define log_error(message,...)
Definition log.h:104
FC_STATIC_ASSERT
#define FC_STATIC_ASSERT(cond, tag)
Definition log.h:238
fc_assert_ret_val_msg
#define fc_assert_ret_val_msg(condition, val, message,...)
Definition log.h:209
real_map_distance
int real_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:675
MAP_DISTANCE_MAX
#define MAP_DISTANCE_MAX
Definition map.h:683
FC_FREE
#define FC_FREE(ptr)
Definition mem.h:41
fc_malloc
#define fc_malloc(sz)
Definition mem.h:34
can_see_techs_of_target
bool can_see_techs_of_target(const struct player *pow_player, const struct player *target_player)
Definition metaknowledge.c:885
mke_eval_reqs
enum fc_tristate mke_eval_reqs(const struct player *pov_player, const struct req_context *context, const struct req_context *other_context, const struct requirement_vector *reqs, const enum req_problem_type prob_type)
Definition metaknowledge.c:859
can_unit_exist_at_tile
bool can_unit_exist_at_tile(const struct civ_map *nmap, const struct unit *punit, const struct tile *ptile)
Definition movement.c:350
is_native_tile
bool is_native_tile(const struct unit_type *punittype, const struct tile *ptile)
Definition movement.c:362
unit_move_rate
int unit_move_rate(const struct unit *punit)
Definition movement.c:89
unit_could_load_at
bool unit_could_load_at(const struct unit *punit, const struct tile *ptile)
Definition movement.c:962
can_unit_type_transport
bool can_unit_type_transport(const struct unit_type *transporter, const struct unit_class *transported)
Definition movement.c:919
can_attack_non_native
bool can_attack_non_native(const struct unit_type *utype)
Definition movement.c:213
oblig_hard_reqs_init
void oblig_hard_reqs_init(void)
Definition oblig_reqs.c:810
oblig_hard_reqs_free
void oblig_hard_reqs_free(void)
Definition oblig_reqs.c:830
hard_code_oblig_hard_reqs_ruleset
void hard_code_oblig_hard_reqs_ruleset(void)
Definition oblig_reqs.c:773
hard_code_oblig_hard_reqs
void hard_code_oblig_hard_reqs(void)
Definition oblig_reqs.c:253
oblig_hard_reqs_get
struct obligatory_req_vector * oblig_hard_reqs_get(enum action_result res)
Definition oblig_reqs.c:855
oblig_hard_reqs_get_sub
struct obligatory_req_vector * oblig_hard_reqs_get_sub(enum action_sub_result res)
Definition oblig_reqs.c:866
oblig_reqs.h
obligatory_req_vector_iterate_end
#define obligatory_req_vector_iterate_end
Definition oblig_reqs.h:48
obligatory_req_vector_iterate
#define obligatory_req_vector_iterate(obreq_vec, pobreq)
Definition oblig_reqs.h:46
can_player_see_tile
bool can_player_see_tile(const struct player *plr, const struct tile *ptile)
Definition player.c:1082
can_player_see_unit
bool can_player_see_unit(const struct player *pplayer, const struct unit *punit)
Definition player.c:1095
pplayers_at_war
bool pplayers_at_war(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1376
player_can_see_city_externals
bool player_can_see_city_externals(const struct player *pow_player, const struct city *target_city)
Definition player.c:1155
pplayers_allied
bool pplayers_allied(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1397
can_player_see_hypotetic_units_at
bool can_player_see_hypotetic_units_at(const struct player *pplayer, const struct tile *ptile)
Definition player.c:984
player_can_trust_tile_has_no_units
bool player_can_trust_tile_has_no_units(const struct player *pplayer, const struct tile *ptile)
Definition player.c:958
universal_never_there
bool universal_never_there(const struct universal *source)
Definition requirements.c:7227
req_context_empty
const struct req_context * req_context_empty(void)
Definition requirements.c:1151
req_to_fstring
const char * req_to_fstring(const struct requirement *req, struct astring *astr)
Definition requirements.c:1166
universal_fulfills_requirements
bool universal_fulfills_requirements(bool check_necessary, const struct requirement_vector *reqs, const struct universal *source)
Definition requirements.c:8766
req_vec_suggest_repair
struct req_vec_problem * req_vec_suggest_repair(const struct requirement_vector *vec, requirement_vector_number get_num, const void *parent_item)
Definition requirements.c:7654
req_vec_problem_new
struct req_vec_problem * req_vec_problem_new(int num_suggested_solutions, const char *descr,...)
Definition requirements.c:7541
are_reqs_active
bool are_reqs_active(const struct req_context *context, const struct req_context *other_context, const struct requirement_vector *reqs, const enum req_problem_type prob_type)
Definition requirements.c:6868
req_vec_first_contradiction_in_vec
struct requirement * req_vec_first_contradiction_in_vec(const struct requirement *req, const struct requirement_vector *vec)
Definition requirements.c:2174
does_req_contradicts_reqs
bool does_req_contradicts_reqs(const struct requirement *req, const struct requirement_vector *vec)
Definition requirements.c:2194
req_vec_is_impossible_to_fulfill
bool req_vec_is_impossible_to_fulfill(const struct requirement_vector *reqs)
Definition requirements.c:7334
req_vec_suggest_improvement
struct req_vec_problem * req_vec_suggest_improvement(const struct requirement_vector *vec, requirement_vector_number get_num, const void *parent_item)
Definition requirements.c:7829
requirement_fulfilled_by_unit_type
#define requirement_fulfilled_by_unit_type(_ut_, _rqs_)
Definition requirements.h:435
req_vec_num_in_item
signed char req_vec_num_in_item
req_vec_num_in_item a requirement vectors number in an item.
Definition requirements.h:243
requirement_vector_iterate_end
#define requirement_vector_iterate_end
Definition requirements.h:94
requirement_fulfilled_by_government
#define requirement_fulfilled_by_government(_gov_, _rqs_)
Definition requirements.h:418
requirement_vector_iterate
#define requirement_vector_iterate(req_vec, preq)
Definition requirements.h:92
research_get
struct research * research_get(const struct player *pplayer)
Definition research.c:130
research_invention_state
enum tech_state research_invention_state(const struct research *presearch, Tech_type_id tech)
Definition research.c:622
research_invention_gettable
bool research_invention_gettable(const struct research *presearch, const Tech_type_id tech, bool allow_holes)
Definition research.c:696
server_setting_by_name
server_setting_id server_setting_by_name(const char *name)
Definition server_settings.c:29
server_setting_value_int_get
int server_setting_value_int_get(server_setting_id id)
Definition server_settings.c:82
server_settings.h
fc_tristate_and
enum fc_tristate fc_tristate_and(enum fc_tristate one, enum fc_tristate two)
Definition shared.c:127
fc_tristate
fc_tristate
Definition shared.h:46
TRI_YES
@ TRI_YES
Definition shared.h:46
TRI_NO
@ TRI_NO
Definition shared.h:46
TRI_MAYBE
@ TRI_MAYBE
Definition shared.h:46
CLIP
#define CLIP(lower, current, upper)
Definition shared.h:57
MIN
#define MIN(x, y)
Definition shared.h:55
MAX
#define MAX(x, y)
Definition shared.h:54
is_super_specialist
bool is_super_specialist(const struct specialist *sp)
Definition specialist.c:212
size
size_t size
Definition specvec.h:72
act_prob
Definition fc_types.h:935
act_prob::max
int max
Definition fc_types.h:937
act_prob::min
int min
Definition fc_types.h:936
action_auto_perf
Definition actions.h:325
action_auto_perf::cause
enum action_auto_perf_cause cause
Definition actions.h:327
action_auto_perf::alternatives
action_id alternatives[MAX_NUM_ACTIONS]
Definition actions.h:335
action_enabler
Definition actions.h:170
action_enabler::action
action_id action
Definition actions.h:171
action_enabler::actor_reqs
struct requirement_vector actor_reqs
Definition actions.h:172
action_enabler::target_reqs
struct requirement_vector target_reqs
Definition actions.h:173
action::unitwaittime_controlled
bool unitwaittime_controlled
Definition actions.h:160
action::id
action_id id
Definition actions.h:111
action::actor_consuming_always
bool actor_consuming_always
Definition actions.h:144
action::rare_pop_up
bool rare_pop_up
Definition actions.h:157
action::max_distance
int max_distance
Definition actions.h:127
action::quiet
bool quiet
Definition actions.h:134
action::sub_target_kind
enum action_sub_target_kind sub_target_kind
Definition actions.h:119
action::moves_actor
enum moves_actor_kind moves_actor
Definition actions.h:164
action::is_unit
struct action::@12::@13 is_unit
action::result
enum action_result result
Definition actions.h:114
action::ui_name
char ui_name[MAX_LEN_NAME]
Definition actions.h:130
action::sub_results
bv_action_sub_results sub_results
Definition actions.h:115
action::actor_kind
enum action_actor_kind actor_kind
Definition actions.h:117
action::target_complexity
enum act_tgt_compl target_complexity
Definition actions.h:122
action::blocked_by
bv_actions blocked_by
Definition actions.h:138
action::configured
bool configured
Definition actions.h:112
action::actor
union action::@12 actor
action::target_kind
enum action_target_kind target_kind
Definition actions.h:118
action::min_distance
int min_distance
Definition actions.h:127
city
Definition city.h:318
city::id
int id
Definition city.h:324
city::tile
struct tile * tile
Definition city.h:320
civ_game::info
struct packet_game_info info
Definition game.h:89
civ_map
Definition map_types.h:71
extra_type
Definition extras.h:88
functions::player_tile_city_id_get
int(* player_tile_city_id_get)(const struct tile *ptile, const struct player *pplayer)
Definition fc_interface.h:52
impr_type
Definition improvement.h:50
packet_game_info::tech_steal_allow_holes
bool tech_steal_allow_holes
Definition packets_gen.h:217
packet_game_info::airlifting_style
enum airlifting_style airlifting_style
Definition packets_gen.h:123
packet_game_info::airlift_from_always_enabled
bool airlift_from_always_enabled
Definition packets_gen.h:124
packet_game_info::diplchance_initial_odds
bv_actions diplchance_initial_odds
Definition packets_gen.h:155
req_context
Definition requirements.h:100
req_context::tile
const struct tile * tile
Definition requirements.h:103
req_context::player
const struct player * player
Definition requirements.h:101
req_context::unit
const struct unit * unit
Definition requirements.h:106
req_context::city
const struct city * city
Definition requirements.h:102
req_vec_problem
Definition requirements.h:304
tile
Definition tile.h:50
unit_class
Definition unittype.h:149
unit_type
Definition unittype.h:505
unit_type::veteran
struct veteran_system * veteran
Definition unittype.h:551
unit
Definition unit.h:139
unit::moves_left
int moves_left
Definition unit.h:151
unit::tile
struct tile * tile
Definition unit.h:141
unit::paradropped
bool paradropped
Definition unit.h:176
unit::utype
const struct unit_type * utype
Definition unit.h:140
universal::kind
enum universals_n kind
Definition fc_types.h:595
veteran_level
Definition unittype.h:491
fc_strcasecmp
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:186
fc__attribute
#define fc__attribute(x)
Definition support.h:99
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
fc__fallthrough
#define fc__fallthrough
Definition support.h:119
advance_number
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:100
advance_iterate
#define advance_iterate(_p)
Definition tech.h:273
advance_iterate_end
#define advance_iterate_end
Definition tech.h:274
tile_is_seen
bool tile_is_seen(const struct tile *target_tile, const struct player *pow_player)
Definition tile.c:408
tile_city
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
tile_owner
#define tile_owner(_tile)
Definition tile.h:97
unit_transport_get
struct unit * unit_transport_get(const struct unit *pcargo)
Definition unit.c:2526
unit_can_do_action
bool unit_can_do_action(const struct unit *punit, const action_id act_id)
Definition unit.c:402
unit_transported
bool unit_transported(const struct unit *pcargo)
Definition unit.c:2512
can_unit_unload
bool can_unit_unload(const struct unit *pcargo, const struct unit *ptrans)
Definition unit.c:793
unit_can_convert
bool unit_can_convert(const struct civ_map *nmap, const struct unit *punit)
Definition unit.c:2089
unit_tile
#define unit_tile(_pu)
Definition unit.h:408
unit_owner
#define unit_owner(_pu)
Definition unit.h:407
unit_home
#define unit_home(_pu_)
Definition unit.h:405
unit_list_iterate
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
unit_list_iterate_end
#define unit_list_iterate_end
Definition unitlist.h:33
unit_type_get
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:126
utype_may_act_move_frags
bool utype_may_act_move_frags(const struct unit_type *punit_type, const action_id act_id, const int move_fragments)
Definition unittype.c:1083
utype_veteran_level
const struct veteran_level * utype_veteran_level(const struct unit_type *punittype, int level)
Definition unittype.c:2634
unit_has_type_flag
bool unit_has_type_flag(const struct unit *punit, enum unit_type_flag_id flag)
Definition unittype.c:215
utype_can_do_act_if_tgt_citytile
bool utype_can_do_act_if_tgt_citytile(const struct unit_type *punit_type, const action_id act_id, const enum citytile_type prop, const bool is_there)
Definition unittype.c:1021
utype_can_do_action
bool utype_can_do_action(const struct unit_type *putype, const action_id act_id)
Definition unittype.c:396
utype_class
#define utype_class(_t_)
Definition unittype.h:756
L_LAST
#define L_LAST
Definition unittype.h:444
unit_type_iterate
#define unit_type_iterate(_p)
Definition unittype.h:865
unit_type_iterate_end
#define unit_type_iterate_end
Definition unittype.h:872
U_NOT_OBSOLETED
#define U_NOT_OBSOLETED
Definition unittype.h:535
Generated on Sun Oct 25 2026 22:31:30 for Freeciv-3.4 by doxygen 1.9.8