Freeciv-3.3
Loading...
Searching...
No Matches
combat.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
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>
19
20/* utility */
21#include "bitvector.h"
22#include "rand.h"
23#include "log.h"
24
25/* common */
26#include "base.h"
27#include "game.h"
28#include "map.h"
29#include "movement.h"
30#include "packets.h"
31#include "unit.h"
32#include "unitlist.h"
33#include "unittype.h"
34
35#include "combat.h"
36
37/*******************************************************************/
44static bool can_player_attack_tile(const struct player *pplayer,
45 const struct tile *ptile)
46{
47 struct city *pcity = tile_city(ptile);
48
49 /* 1. Is there anyone there at all? */
50 if (pcity == NULL && unit_list_size((ptile->units)) == 0) {
51 return FALSE;
52 }
53
54 /* 2. If there is a city there, can we attack it? */
55 if (pcity != NULL && !pplayers_at_war(city_owner(pcity), pplayer)) {
56 return FALSE;
57 }
58
59 /* 3. Are we allowed to attack _all_ units there? */
62 && !pplayers_at_war(unit_owner(aunit), pplayer)) {
63 /* Enemy hiding behind a human/diplomatic shield */
64 return FALSE;
65 }
67
68 return TRUE;
69}
70
71/*******************************************************************/
74static bool is_unit_reachable_by_unit(const struct unit *defender,
75 const struct unit *attacker)
76{
77 struct unit_class *dclass = unit_class_get(defender);
78 const struct unit_type *atype = unit_type_get(attacker);
79
80 return BV_ISSET(atype->targets, uclass_index(dclass));
81}
82
83/*******************************************************************/
86bool is_unit_reachable_at(const struct unit *defender,
87 const struct unit *attacker,
88 const struct tile *location)
89{
90 if (NULL != tile_city(location)) {
91 return TRUE;
92 }
93
94 if (is_unit_reachable_by_unit(defender, attacker)) {
95 return TRUE;
96 }
97
98 if (tile_has_native_base(location, unit_type_get(defender))) {
99 return TRUE;
100 }
101
102 return FALSE;
103}
104
105/*******************************************************************/
124 const struct action *paction,
125 const struct unit *pdefender,
126 const struct tile *dest_tile)
127{
128 /* 1. Can we attack _anything_ ? */
129 if (paction == NULL) {
133 /* Needed because ACTION_NUKE_UNITS uses this when evaluating its
134 * hard requirements. */
137 return ATT_NON_ATTACK;
138 }
139 } else {
141 return ATT_NON_ATTACK;
142 }
143 }
144
145 /* 2. Can't attack with ground unit from ocean, except for marines */
146 if (paction == NULL) {
154 return ATT_NONNATIVE_SRC;
155 }
156 } else {
159 paction->id,
161 return ATT_NONNATIVE_SRC;
162 }
163 }
164
165 /* 3. Most units can not attack non-native terrain.
166 * Most ships can attack land tiles (shore bombardment) */
167 if (!is_native_tile(unit_type_get(punit), dest_tile)
169 return ATT_NONNATIVE_DST;
170 }
171
172 /* 4. Only fighters can attack planes, except in city or airbase attacks */
173 if (!is_unit_reachable_at(pdefender, punit, dest_tile)) {
174 return ATT_UNREACHABLE;
175 }
176
177 /* Unreachability check must remain the last check, as callers interpret
178 * ATT_UNREACHABLE as "ATT_OK except that unreachable." */
179
180 return ATT_OK;
181}
182
183/*******************************************************************/
188static enum unit_attack_result
190 const struct action *paction,
191 const struct tile *ptile)
192{
195
196 unit_list_iterate(ptile->units, aunit) {
197 /* HACK: We don't count transported units here. This prevents some
198 * bugs like a submarine carrying a cruise missile being invulnerable
199 * to other sea units. However from a gameplay perspective it's a hack,
200 * since players can load and unload their units manually to protect
201 * their transporters. */
202 if (!unit_transported(aunit)) {
203 enum unit_attack_result result;
204
206 aunit, ptile);
207 if (result == ATT_UNREACHABLE
209 /* Doesn't prevent us from attacking other units on the tile */
211 continue;
212 } else if (result != ATT_OK) {
213 return result;
214 }
216 }
218
219 /* If there are only unreachable, UTYF_NEVER_PROTECTS units, we still have
220 * to return ATT_UNREACHABLE. */
222}
223
224/*******************************************************************/
229static enum unit_attack_result
231 const struct action *paction,
232 const struct tile *ptile)
233{
234 enum unit_attack_result result = ATT_OK;
235
236 unit_list_iterate(ptile->units, aunit) {
237 /* HACK: we don't count transported units here. This prevents some
238 * bugs like a cargoplane carrying a land unit being vulnerable. */
239 if (!unit_transported(aunit)) {
241 aunit, ptile);
242 if (result == ATT_OK) {
243 return result;
244 }
245 }
247
248 /* That's result from check against last unit on tile, not first.
249 * Shouldn't matter. */
250 return result;
251}
252
253/*******************************************************************/
258 const struct action *paction,
259 const struct tile *ptile)
260{
263 } else {
265 }
266}
267
268/*******************************************************************/
273 const struct tile *ptile)
274{
275 /* Can unit wipe in general? */
277 return ATT_NON_ATTACK;
278 }
279
280 unit_list_iterate(ptile->units, target) {
281 if (get_total_defense_power(punit, target) > 0) {
282 return ATT_NOT_WIPABLE;
283 }
284
285 /* Can't wipe with ground unit from ocean, except for marines */
289 return ATT_NONNATIVE_SRC;
290 }
291
292 /* Most units can not wipe on non-native terrain.
293 * Most ships can wipe on land tiles (shore bombardment) */
296 return ATT_NONNATIVE_DST;
297 }
298
299 /* Only fighters can wipe planes, except in city or airbase attacks */
300 if (!is_unit_reachable_at(target, punit, ptile)) {
301 return ATT_UNREACHABLE;
302 }
304
305 return ATT_OK;
306}
307
308/*******************************************************************/
312bool can_unit_attack_tile(const struct unit *punit,
313 const struct action *paction,
314 const struct tile *dest_tile)
315{
319 == ATT_OK));
320}
321
322/*******************************************************************/
334double win_chance(int as, int ahp, int afp, int ds, int dhp, int dfp)
335{
336 /* number of rounds a unit can fight without dying */
337 int att_N_lose = (ahp + dfp - 1) / dfp;
338 int def_N_lose = (dhp + afp - 1) / afp;
339 /* Probability of losing one round */
340 double att_P_lose1 = (as + ds == 0) ? 0.5 : (double) ds / (as + ds);
341 double def_P_lose1 = 1 - att_P_lose1;
342
343 /*
344 This calculates
345
346 binomial_coeff(def_N_lose-1 + lr, lr)
347 * def_P_lose1^(def_N_lose-1)
348 * att_P_lose1^(lr)
349 * def_P_lose1
350
351 for each possible number of rounds lost (rl) by the winning unit.
352 rl is of course less than the number of rounds the winning unit
353 should lose to lose all it's hit points.
354 The probabilities are then summed.
355
356 To see this is correct consider the set of series for all valid fights.
357 These series are the type (win, lose, lose...). The possible lengths are
358 def_N_lose to def_N_lose+att_N_lose-1. A series is not valid unless it
359 contains def_N_lose wins, and one of the wins must be the last one, or
360 the series would be equivalent the a shorter series (the attacker would
361 have won one or more fights previously).
362 So since the last fight is a win we disregard it while calculating. Now
363 a series contains def_N_lose-1 wins. So for each possible length of a
364 series we find the probability of every valid series and then sum.
365 For a specific length (a "lr") every series have the probability
366 def_P_lose1^(def_N_lose-1) * att_P_lose1^(lr)
367 and then getting from that to the real series requires a win, ie factor
368 def_N_lose. The number of series with length (def_N_lose-1 + lr) and
369 "lr" lost fights is
370 binomial_coeff(def_N_lose-1 + lr, lr)
371 And by multiplying we get the formula on the top of this code block.
372 Adding the cumulative probability for each valid length then gives the
373 total probability.
374
375 We clearly have all valid series this way. To see that we have counted
376 none twice note that would require a series with a smaller series inbedded.
377 But since the smaller series already included def_N_lose wins, and the
378 larger series ends with a win, it would have too many wins and therefore
379 cannot exist.
380
381 In practice each binomial coefficient for a series length can be calculated
382 from the previous. In the coefficient (n, k) n is increased and k is
383 unchanged.
384 The "* def_P_lose1" is multiplied on the sum afterwards.
385
386 (lots of talk for so little code)
387 */
388
389 double binom_save = pow(def_P_lose1, (double)(def_N_lose - 1));
390 double accum_prob = binom_save; /* lr = 0 */
391
392 int lr; /* the number of Lost Rounds by the attacker */
393 for (lr = 1; lr < att_N_lose; lr++) {
394 /* update the coefficient */
395 int n = lr + def_N_lose - 1;
396 binom_save *= n;
397 binom_save /= lr;
399 /* use it for this lr */
401 }
402 /* Every element of the sum needs a factor for the very last fight round */
404
405 return accum_prob;
406}
407
408/*******************************************************************/
412 const struct unit *attacker,
413 const struct unit *defender,
414 int *att_fp, int *def_fp)
415{
416 struct city *pcity = tile_city(unit_tile(defender));
417 const struct unit_type *att_type;
418 const struct unit_type *def_type;
419 struct tile *att_tile;
420
421 att_type = unit_type_get(attacker);
422 def_type = unit_type_get(defender);
423
424 *att_fp = att_type->firepower;
425 *def_fp = def_type->firepower;
426
427 /* Check CityBuster flag */
428 if (unit_has_type_flag(attacker, UTYF_CITYBUSTER) && pcity) {
429 *att_fp *= 2;
430 }
431
432 /*
433 * UTYF_BADWALLATTACKER reduces the firepower of the attacking unit to
434 * badwallattacker firepower if an EFT_DEFEND_BONUS applies
435 * (such as a land unit attacking a city with city walls).
436 */
438 && get_unittype_bonus(unit_owner(defender), unit_tile(defender),
439 att_type, NULL,
440 EFT_DEFEND_BONUS) > 0) {
442 }
443
444 /* pearl harbor - defender's firepower is reduced,
445 * attacker's is multiplied by two */
447 && tile_city(unit_tile(defender))) {
448 *att_fp *= 2;
450 }
451
452 /*
453 * When attacked by fighters, helicopters have their firepower
454 * reduced to low firepower bonus.
455 */
459 }
460
461 att_tile = unit_tile(attacker);
462
463 /* In land bombardment both units have their firepower reduced.
464 * Land bombardment is always towards tile not native for attacker.
465 * It's initiated either from a tile not native to defender (Ocean for Land unit)
466 * or from a tile where attacker is despite non-native terrain (city, transport) */
468 && !is_native_tile(att_type, unit_tile(defender))
473 }
474}
475
476/*******************************************************************/
480double unit_win_chance(const struct civ_map *nmap,
481 const struct unit *attacker,
482 const struct unit *defender,
483 const struct action *paction)
484{
485 int def_power = get_total_defense_power(attacker, defender);
486 int att_power = get_total_attack_power(attacker, defender, paction);
487 double chance;
488 int def_fp, att_fp;
489
490 get_modified_firepower(nmap, attacker, defender, &att_fp, &def_fp);
491
492 chance = win_chance(att_power, attacker->hp, att_fp,
493 def_power, defender->hp, def_fp);
494
495 return chance;
496}
497
498/*******************************************************************/
503struct city *sdi_try_defend(const struct civ_map *nmap,
504 const struct player *owner,
505 const struct tile *ptile)
506{
507 square_iterate(nmap, ptile, 2, ptile1) {
508 struct city *pcity = tile_city(ptile1);
509
510 if (pcity
511 && fc_rand(100)
513 &(const struct req_context) {
514 .player = city_owner(pcity),
515 .city = pcity,
516 .tile = ptile,
517 },
518 &(const struct req_context) {
519 .player = owner,
520 },
522 return pcity;
523 }
525
526 return NULL;
527}
528
529/*******************************************************************/
532bool is_tired_attack(int moves_left)
533{
534 return game.info.tired_attack && moves_left < SINGLE_MOVE;
535}
536
537/*******************************************************************/
545
546/*******************************************************************/
551 int veteran, int moves_left)
552{
553 int power;
554 const struct veteran_level *vlevel;
555
557
560
561 power = punittype->attack_strength * POWER_FACTOR
562 * vlevel->power_fact / 100;
563
564 if (is_tired_attack(moves_left)) {
565 power = (power * moves_left) / SINGLE_MOVE;
566 }
567
568 return power;
569}
570
571/*******************************************************************/
575{
576 const struct veteran_level *vlevel;
577 const struct unit_type *ptype;
578
580
584
585 return ptype->defense_strength * POWER_FACTOR
586 * vlevel->power_fact / 100;
587}
588
589/*******************************************************************/
594static int get_defense_power(const struct unit *punit)
595{
597 struct tile *ptile = unit_tile(punit);
599
601 db = 100 + tile_terrain(ptile)->defense_bonus;
602 power = (power * db) / 100;
603 }
604
605 if (!is_native_tile_to_class(pclass, ptile)) {
606 power = power * pclass->non_native_def_pct / 100;
607 }
608
609 return power;
610}
611
612/*******************************************************************/
615int get_total_attack_power(const struct unit *attacker,
616 const struct unit *defender,
617 const struct action *paction)
618{
619 int mod;
620 int attackpower = get_attack_power(attacker);
621 struct tile *deftile = unit_tile(defender);
622 struct city *pcity = tile_city(deftile);
623
624 /* Note: get_unit_bonus() would use the tile unit is on,
625 * but we want defending tile. */
626 mod = 100 + get_target_bonus_effects(NULL,
627 &(const struct req_context) {
628 .player = unit_owner(attacker),
629 .city = pcity,
630 .tile = deftile,
631 .unit = attacker,
632 .unittype = unit_type_get(attacker),
633 .action = paction,
634 },
636
637 return attackpower * mod / 100;
638}
639
640/*******************************************************************/
651 const struct unit *def,
652 const struct player *def_player,
653 const struct tile *ptile,
654 int defensepower)
655{
656 const struct city *pcity = tile_city(ptile);
657 const struct unit_type *def_type = unit_type_get(def);
658
660
661 if (NULL != att_type) {
662 int scramble_bonus = 0;
664
665 if (pcity) {
666 scramble_bonus = def_type->cache.scramble_coeff[utype_index(att_type)];
667 }
668
669 if (scramble_bonus) {
670 /* Use type-specific city bonus,
671 * already multiplied on common type-specific bonus */
674 } else {
675 /* Use city defense effect */
676 int defense_multiplier_pct = 100
677 + def_type->cache.defense_mp_bonuses_pct[utype_index(att_type)];
678 int mod = 100 + get_unittype_bonus(def_player, ptile,
680
681 /* This applies even if pcity is NULL. */
683 defensepower = MAX(0, defensepower * mod / 100);
684 }
685
688 + 100 * combat_bonus_against(att_type->bonuses, def_type,
690
692 }
693
694 defensepower +=
696
698 * (100
700 &(const struct req_context) {
701 .player = unit_owner(def),
702 .city = pcity,
703 .tile = ptile,
704 .unit = def,
705 .unittype = unit_type_get(def),
706 },
707 NULL,
709
710 return defensepower;
711}
712
713/*******************************************************************/
718 const struct unit_type *att_type,
719 const struct unit_type *def_type,
720 struct player *def_player,
721 struct tile *ptile,
722 bool fortified, int veteran)
723{
724 int defensepower = def_type->defense_strength;
725 int db;
726 const struct veteran_level *vlevel;
727 struct unit_class *defclass;
728 struct unit *vdef;
729 int def;
730
732
733 if (!can_exist_at_tile(nmap, def_type, ptile)) {
734 /* Ground units on ship doesn't defend. */
735 return 0;
736 }
737
740
742
744 unit_tile_set(vdef, ptile);
745 if (fortified) {
746 vdef->activity = ACTIVITY_FORTIFIED;
747 }
748
751 db += tile_terrain(ptile)->defense_bonus / (100 / POWER_FACTOR);
752 }
753 defensepower *= db;
754 defensepower *= vlevel->power_fact / 100;
755 if (!is_native_tile_to_class(defclass, ptile)) {
756 defensepower = defensepower * defclass->non_native_def_pct / 100;
757 }
758
760 ptile, defensepower);
761
763
764 return def;
765}
766
767/*******************************************************************/
772int get_total_defense_power(const struct unit *attacker,
773 const struct unit *defender)
774{
775 return defense_multiplication(unit_type_get(attacker),
776 defender,
777 unit_owner(defender), unit_tile(defender),
778 get_defense_power(defender));
779}
780
781/*******************************************************************/
786int get_fortified_defense_power(const struct unit *attacker,
787 struct unit *defender)
788{
789 const struct unit_type *att_type = NULL;
791 int def;
792 const struct unit_type *utype;
793
794 if (attacker != NULL) {
795 att_type = unit_type_get(attacker);
796 }
797
798 real_act = defender->activity;
799
800 utype = unit_type_get(defender);
802 defender->activity = ACTIVITY_FORTIFIED;
803 }
804
805 def = defense_multiplication(att_type, defender,
806 unit_owner(defender), unit_tile(defender),
807 get_defense_power(defender));
808
809 defender->activity = real_act;
810
811 return def;
812}
813
814/*******************************************************************/
819static int get_defense_rating(const struct civ_map *nmap,
820 const struct unit *attacker,
821 const struct unit *defender)
822{
823 int afp, dfp;
824 int rating = get_total_defense_power(attacker, defender);
825
826 get_modified_firepower(nmap, attacker, defender, &afp, &dfp);
827
828 /* How many rounds the defender will last */
829 rating *= (defender->hp + afp-1)/afp;
830
831 rating *= dfp;
832
833 return rating;
834}
835
836/*******************************************************************/
841struct unit *get_defender(const struct civ_map *nmap,
842 const struct unit *attacker,
843 const struct tile *ptile,
844 const struct action *paction)
845{
846 struct unit *bestdef = NULL;
847 int bestvalue = -99, best_cost = 0, rating_of_best = 0;
848
849 /* Simply call unit_win_chance() with all the possible defenders in turn, and
850 * take the best one. It currently uses build cost as a tiebreaker in
851 * case 2 units are identical, but this is crude as build cost does not
852 * necessarily have anything to do with the value of a unit. This function
853 * could be improved to take the value of the unit into account. It would
854 * also be nice if the function was a bit more fuzzy about prioritizing,
855 * making it able to fx choose a 1a/9d unit over a 10a/10d unit. It should
856 * also be able to spare units without full hp's to some extent, as these
857 * could be more valuable later. */
858 unit_list_iterate(ptile->units, defender) {
859 /* We used to skip over allied units, but the logic for that is
860 * complicated and is now handled elsewhere. */
861 if (unit_can_defend_here(nmap, defender)
862 && (unit_attack_unit_at_tile_result(attacker, NULL, defender, ptile)
863 == ATT_OK)) {
864 bool change = FALSE;
865 int build_cost = unit_build_shield_cost_base(defender);
866 int defense_rating = get_defense_rating(nmap, attacker, defender);
867 /* This will make units roughly evenly good defenders look alike. */
868 int unit_def
869 = (int) (100000 * (1 - unit_win_chance(nmap, attacker,
870 defender, paction)));
871
872 fc_assert_action(0 <= unit_def, continue);
873
874 if (unit_has_type_flag(defender, UTYF_GAMELOSS)
875 && !is_stack_vulnerable(unit_tile(defender))) {
876 unit_def = -1; /* Then always use leader as last defender. */
877 /* FIXME: Multiple gameloss units with varying defense value
878 * not handled. */
879 }
880
881 if (unit_def > bestvalue) {
882 change = TRUE;
883 } else if (unit_def == bestvalue) {
884 if (build_cost < best_cost) {
885 change = TRUE;
886 } else if (build_cost == best_cost) {
888 change = TRUE;
889 }
890 }
891 }
892
893 if (change) {
895 bestdef = defender;
896 best_cost = build_cost;
898 }
899 }
901
902 return bestdef;
903}
904
905/*******************************************************************/
911struct unit *get_attacker(const struct civ_map *nmap,
912 const struct unit *defender,
913 const struct tile *ptile)
914{
915 struct unit *bestatt = 0;
916 int bestvalue = -1, unit_a, best_cost = 0;
917
918 unit_list_iterate(ptile->units, attacker) {
919 int build_cost = unit_build_shield_cost_base(attacker);
920
921 if (pplayers_allied(unit_owner(defender), unit_owner(attacker))) {
922 return NULL;
923 }
924 unit_a = (int) (100000 * (unit_win_chance(nmap, attacker,
925 defender, NULL)));
926 if (unit_a > bestvalue
927 || (unit_a == bestvalue && build_cost < best_cost)) {
929 bestatt = attacker;
930 best_cost = build_cost;
931 }
933
934 return bestatt;
935}
936
937/**********************************************************************/
948 const struct unit *pvictim,
949 const struct tile *tgt_tile,
950 const struct action *paction)
951{
954
957 /* I can't confirm if we won't deny that we weren't involved.
958 * (Won't defend against its owner.) */
959 continue;
960 }
961
962 if (punit == pvictim
964 /* The victim unit is defenseless unless it's a SuperSpy.
965 * Rationalization: A regular diplomat don't mind being bribed. A
966 * SuperSpy is high enough up the chain that accepting a bribe is
967 * against their own interests. */
968 continue;
969 }
970
973 /* A UTYF_SUPERSPY unit may not actually be a spy, but a superboss
974 * which we cannot allow puny diplomats from getting the better
975 * of. UTYF_SUPERSPY vs UTYF_SUPERSPY in a diplomatic contest always
976 * kills the attacker. */
977
978 /* The unit can't defend in a diplomatic battle. */
979 continue;
980 }
981
982 /* The first potential defender found is chosen. No priority is given
983 * to the best defender. */
984 return punit;
986
987 /* No diplomatic defender found. */
988 return NULL;
989}
990
991/*******************************************************************/
994bool is_stack_vulnerable(const struct tile *ptile)
995{
996 return (game.info.killstack
998 && NULL == tile_city(ptile));
999}
1000
1001/*******************************************************************/
1008 const struct unit_type *enemy,
1010{
1011 int value = 0;
1012
1014 if (pbonus->type == type && utype_has_flag(enemy, pbonus->flag)) {
1015 value += pbonus->value;
1016 }
1018
1019 return value;
1020}
1021
1022/*******************************************************************/
1026{
1027 const struct unit_type *utype = unit_type_get(punit);
1028 int base_bombard_rate = utype->bombard_rate;
1029
1031 int rate = (base_bombard_rate * punit->hp) / utype->hp;
1032
1033 return MAX(rate, 1);
1034 }
1035
1036 return base_bombard_rate;
1037}
#define n
Definition astring.c:77
#define BV_ISSET(bv, bit)
Definition bitvector.h:86
#define city_owner(_pcity_)
Definition city.h:560
static struct fc_sockaddr_list * list
Definition clinet.c:102
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
bool is_unit_reachable_at(const struct unit *defender, const struct unit *attacker, const struct tile *location)
Definition combat.c:86
bool is_stack_vulnerable(const struct tile *ptile)
Definition combat.c:994
int get_virtual_defense_power(const struct civ_map *nmap, const struct unit_type *att_type, const struct unit_type *def_type, struct player *def_player, struct tile *ptile, bool fortified, int veteran)
Definition combat.c:717
static enum unit_attack_result unit_attack_any_at_tile_result(const struct unit *punit, const struct action *paction, const struct tile *ptile)
Definition combat.c:230
int get_attack_power(const struct unit *punit)
Definition combat.c:540
int unit_bombard_rate(struct unit *punit)
Definition combat.c:1025
int combat_bonus_against(const struct combat_bonus_list *list, const struct unit_type *enemy, enum combat_bonus_type type)
Definition combat.c:1007
int get_fortified_defense_power(const struct unit *attacker, struct unit *defender)
Definition combat.c:786
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
static int get_defense_rating(const struct civ_map *nmap, const struct unit *attacker, const struct unit *defender)
Definition combat.c:819
struct unit * get_attacker(const struct civ_map *nmap, const struct unit *defender, const struct tile *ptile)
Definition combat.c:911
int base_get_attack_power(const struct unit_type *punittype, int veteran, int moves_left)
Definition combat.c:550
struct city * sdi_try_defend(const struct civ_map *nmap, const struct player *owner, const struct tile *ptile)
Definition combat.c:503
int get_total_defense_power(const struct unit *attacker, const struct unit *defender)
Definition combat.c:772
int get_total_attack_power(const struct unit *attacker, const struct unit *defender, const struct action *paction)
Definition combat.c:615
enum unit_attack_result unit_attack_unit_at_tile_result(const struct unit *punit, const struct action *paction, const struct unit *pdefender, const struct tile *dest_tile)
Definition combat.c:123
static enum unit_attack_result unit_attack_all_at_tile_result(const struct unit *punit, const struct action *paction, const struct tile *ptile)
Definition combat.c:189
static int get_defense_power(const struct unit *punit)
Definition combat.c:594
bool is_tired_attack(int moves_left)
Definition combat.c:532
static int defense_multiplication(const struct unit_type *att_type, const struct unit *def, const struct player *def_player, const struct tile *ptile, int defensepower)
Definition combat.c:650
double win_chance(int as, int ahp, int afp, int ds, int dhp, int dfp)
Definition combat.c:334
enum unit_attack_result unit_wipe_units_at_tile_result(const struct unit *punit, const struct tile *ptile)
Definition combat.c:272
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
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
bool can_unit_attack_tile(const struct unit *punit, const struct action *paction, const struct tile *dest_tile)
Definition combat.c:312
int base_get_defense_power(const struct unit *punit)
Definition combat.c:574
void get_modified_firepower(const struct civ_map *nmap, const struct unit *attacker, const struct unit *defender, int *att_fp, int *def_fp)
Definition combat.c:411
static bool can_player_attack_tile(const struct player *pplayer, const struct tile *ptile)
Definition combat.c:44
static bool is_unit_reachable_by_unit(const struct unit *defender, const struct unit *attacker)
Definition combat.c:74
#define POWER_FACTOR
Definition combat.h:32
unit_attack_result
Definition combat.h:34
@ ATT_NOT_WIPABLE
Definition combat.h:40
@ ATT_NONNATIVE_DST
Definition combat.h:39
@ ATT_OK
Definition combat.h:35
@ ATT_NON_ATTACK
Definition combat.h:36
@ ATT_UNREACHABLE
Definition combat.h:37
@ ATT_NONNATIVE_SRC
Definition combat.h:38
char * incite_cost
Definition comments.c:76
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:74
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:78
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
int get_unittype_bonus(const struct player *pplayer, const struct tile *ptile, const struct unit_type *punittype, const struct action *paction, enum effect_type effect_type)
Definition effects.c:1031
struct civ_game game
Definition game.c:61
struct city * owner
Definition citydlg.c:226
GType type
Definition repodlgs.c:1313
#define fc_assert_ret_val(condition, val)
Definition log.h:195
#define fc_assert_action(condition, action)
Definition log.h:188
#define square_iterate(nmap, center_tile, radius, tile_itr)
Definition map.h:388
#define square_iterate_end
Definition map.h:391
bool can_exist_at_tile(const struct civ_map *nmap, const struct unit_type *utype, const struct tile *ptile)
Definition movement.c:289
bool is_native_tile(const struct unit_type *punittype, const struct tile *ptile)
Definition movement.c:330
bool can_attack_non_native_hard_reqs(const struct unit_type *utype)
Definition movement.c:203
bool unit_can_defend_here(const struct civ_map *nmap, const struct unit *punit)
Definition movement.c:173
#define SINGLE_MOVE
Definition movement.h:26
static bool is_native_tile_to_class(const struct unit_class *punitclass, const struct tile *ptile)
Definition movement.h:84
bool pplayers_at_war(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1388
bool pplayers_allied(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1409
#define fc_rand(_size)
Definition rand.h:56
#define MIN(x, y)
Definition shared.h:55
#define MAX(x, y)
Definition shared.h:54
Definition city.h:317
struct packet_game_info info
Definition game.h:89
int low_firepower_pearl_harbor
bool damage_reduces_bombard_rate
int low_firepower_nonnat_bombard
int low_firepower_combat_bonus
int low_firepower_badwallattacker
Definition tile.h:50
struct unit_list * units
Definition tile.h:58
struct veteran_system * veteran
Definition unittype.h:551
int bombard_rate
Definition unittype.h:554
Definition unit.h:140
enum unit_activity activity
Definition unit.h:159
int moves_left
Definition unit.h:152
int hp
Definition unit.h:153
struct tile * tile
Definition unit.h:142
int veteran
Definition unit.h:154
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
bool tile_has_extra_flag(const struct tile *ptile, enum extra_flag_id flag)
Definition tile.c:886
int tile_extras_defense_bonus(const struct tile *ptile, const struct unit_type *punittype)
Definition tile.c:233
bool tile_has_native_base(const struct tile *ptile, const struct unit_type *punittype)
Definition tile.c:324
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
#define tile_terrain(_tile)
Definition tile.h:111
struct unit * unit_virtual_create(struct player *pplayer, struct city *pcity, const struct unit_type *punittype, int veteran_level)
Definition unit.c:1661
void unit_virtual_destroy(struct unit *punit)
Definition unit.c:1766
void unit_tile_set(struct unit *punit, struct tile *ptile)
Definition unit.c:1284
bool unit_transported(const struct unit *pcargo)
Definition unit.c:2502
#define unit_tile(_pu)
Definition unit.h:404
#define unit_owner(_pu)
Definition unit.h:403
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
#define unit_list_iterate_end
Definition unitlist.h:33
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
bool utype_has_class_flag(const struct unit_type *ptype, enum unit_class_flag_id flag)
Definition unittype.c:1663
int unit_build_shield_cost_base(const struct unit *punit)
Definition unittype.c:1490
bool utype_can_do_act_when_ustate(const struct unit_type *punit_type, const action_id act_id, const enum ustate_prop prop, const bool is_there)
Definition unittype.c:961
struct unit_class * unit_class_get(const struct unit *punit)
Definition unittype.c:2505
bool utype_can_do_action_result(const struct unit_type *putype, enum action_result result)
Definition unittype.c:393
const struct veteran_level * utype_veteran_level(const struct unit_type *punittype, int level)
Definition unittype.c:2603
bool unit_has_type_flag(const struct unit *punit, enum unit_type_flag_id flag)
Definition unittype.c:196
Unit_type_id utype_index(const struct unit_type *punittype)
Definition unittype.c:91
bool utype_can_do_action(const struct unit_type *putype, const action_id act_id)
Definition unittype.c:377
static bool uclass_has_flag(const struct unit_class *punitclass, enum unit_class_flag_id flag)
Definition unittype.h:773
#define utype_class(_t_)
Definition unittype.h:756
#define combat_bonus_list_iterate_end
Definition unittype.h:489
#define combat_bonus_list_iterate(bonuslist, pbonus)
Definition unittype.h:487
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition unittype.h:624
#define uclass_index(_c_)
Definition unittype.h:749