58 #define DBG_NG LOG_STREAM(debug, log_engine)
59 #define LOG_NG LOG_STREAM(info, log_engine)
60 #define WRN_NG LOG_STREAM(err, log_engine)
61 #define ERR_NG LOG_STREAM(err, log_engine)
64 #define DBG_AT LOG_STREAM(debug, log_attack)
65 #define LOG_AT LOG_STREAM(info, log_attack)
66 #define WRN_AT LOG_STREAM(err, log_attack)
67 #define ERR_AT LOG_STREAM(err, log_attack)
70 #define LOG_CF LOG_STREAM(info, log_config)
84 , attack_num(u_attack_num)
85 , is_attacker(attacking)
86 , is_poisoned(up->get_state(
unit::STATE_POISONED))
87 , is_slowed(up->get_state(
unit::STATE_SLOWED))
96 , experience(up->experience())
97 , max_experience(up->max_experience())
101 , max_hp(up->max_hitpoints())
113 const unit& opp = *oppp;
120 LOG_CF <<
"Unit with " << u.
hitpoints() <<
" hitpoints found, set to 0 for damage calculations";
136 auto ctx =
weapon->specials_context(up, oppp, u_loc, opp_loc, attacking, opp_weapon);
137 utils::optional<decltype(ctx)> opp_ctx;
140 opp_ctx.emplace(opp_weapon->specials_context(oppp, up, opp_loc, u_loc, !attacking,
weapon));
147 rounds =
weapon->get_specials_and_abilities(
"berserk").highest(
"value", 1).first;
153 const bool out_of_range = distance >
weapon->max_range() || distance <
weapon->min_range();
154 disable =
weapon->has_special_or_ability(
"disable") || out_of_range;
180 double base_damage =
weapon->modified_damage();
183 int damage_multiplier = 100;
192 if(leader_bonus != 0) {
193 damage_multiplier += leader_bonus;
229 unsigned int opp_terrain_defense,
231 : weapon(std::move(att_weapon))
233 , is_attacker(attacking)
260 if(!u_type || !opp_type) {
282 utils::optional<decltype(ctx)> opp_ctx;
292 rounds =
weapon->get_specials(
"berserk").highest(
"value", 1).first;
307 signed int cth =
weapon->modified_chance_to_hit(100 - opp_terrain_defense,
true);
311 double base_damage =
weapon->modified_damage();
312 int damage_multiplier = 100;
351 , attacker_combatant_()
352 , defender_combatant_()
354 std::size_t a_wep_uindex =
static_cast<std::size_t
>(a_wep_index);
355 std::size_t d_wep_uindex =
static_cast<std::size_t
>(d_wep_index);
357 const_attack_ptr a_wep(a_wep_uindex < attacker->attacks().
size() ? attacker->attacks()[a_wep_index].shared_from_this() :
nullptr);
358 const_attack_ptr d_wep(d_wep_uindex < defender->attacks().
size() ? defender->attacks()[d_wep_index].shared_from_this() :
nullptr);
386 : attacker_stats_(nullptr)
387 , defender_stats_(nullptr)
388 , attacker_combatant_(nullptr)
389 , defender_combatant_(nullptr)
401 const double harm_weight = 1.0 - aggression;
403 if(attacker_weapon == -1) {
405 n_attacker, n_defender, attacker_loc, defender_loc, harm_weight, prev_def
408 else if(defender_weapon == -1) {
410 n_attacker, n_defender, attacker_weapon, attacker_loc, defender_loc, prev_def
414 *
this =
battle_context(n_attacker, attacker_loc, attacker_weapon, n_defender, defender_loc, defender_weapon);
424 , attacker_combatant_(nullptr)
425 , defender_combatant_(nullptr)
497 double attack_weight_a = us_a.
u_.
weapon->attack_weight();
498 double attack_weight_b = us_b.
u_.
weapon->attack_weight();
499 double damage_a = (them_a.
u_.
hp - them_a.
average_hp()) * attack_weight_a;
500 double damage_b = (them_b.
u_.
hp - them_b.
average_hp()) * attack_weight_b;
503 a = (us_a.
average_hp() - poison_a_us) * harm_weight + damage_a + poison_a_them;
504 b = (us_b.
average_hp() - poison_b_us) * harm_weight + damage_b + poison_b_them;
515 return damage_a >= damage_b;
526 std::vector<battle_context> choices;
529 for(std::size_t
i = 0;
i < attacker->attacks().
size(); ++
i) {
540 choices.emplace_back(std::move(bc));
543 if(choices.empty()) {
544 return battle_context(attacker, attacker_loc, -1, defender, defender_loc, -1);
547 if(choices.size() == 1) {
548 return std::move(choices[0]);
553 for(
auto& choice : choices) {
557 if(!best_choice || choice.
better_attack(*best_choice, harm_weight)) {
558 best_choice = &choice;
563 return std::move(*best_choice);
566 return battle_context(attacker, attacker_loc, -1, defender, defender_loc, -1);
573 unsigned attacker_weapon,
579 VALIDATE(attacker_weapon < attacker->attacks().
size(),
_(
"An invalid attacker weapon got selected."));
581 const attack_type& att = attacker->attacks()[attacker_weapon];
582 auto no_weapon = [&]() {
return battle_context(attacker, attacker_loc, attacker_weapon, defender, defender_loc, -1); };
583 std::vector<battle_context> choices;
586 for(std::size_t
i = 0;
i < defender->attacks().
size(); ++
i) {
592 battle_context bc(attacker, attacker_loc, attacker_weapon, defender, defender_loc,
i);
601 choices.emplace_back(std::move(bc));
604 if(choices.empty()) {
608 if(choices.size() == 1) {
610 return std::move(choices[0]);
620 double max_weight = 0.0;
622 for(
const auto& choice : choices) {
623 const attack_type& def = defender->attacks()[choice.defender_stats_->attack_num];
629 int rating =
static_cast<int>(
641 for(
auto& choice : choices) {
642 const attack_type& def = defender->attacks()[choice.defender_stats_->attack_num];
644 choice.simulate(prev_def);
647 int simple_rating =
static_cast<int>(
648 choice.defender_stats_->num_blows * choice.defender_stats_->damage * choice.defender_stats_->chance_to_hit * def.
defense_weight());
651 if(simple_rating >= min_rating && (!best_choice || choice.
better_defense(*best_choice, 1.0))) {
652 best_choice = &choice;
656 return best_choice ? std::move(*best_choice) : no_weapon();
666 void refresh_weapon_index(
int& weap_index,
const std::string& weap_id,
const attack_itors& attacks)
669 if(attacks.empty()) {
675 if(weap_index >= 0 && weap_index <
static_cast<int>(attacks.size()) && attacks[weap_index].id() == weap_id) {
680 if(!weap_id.empty()) {
681 for(
int i = 0; i < static_cast<int>(attacks.size()); ++
i) {
682 if(attacks[
i].
id() == weap_id) {
702 bool update_display =
true);
707 class attack_end_exception
713 void fire_event_impl(
const std::string&
n,
bool reversed);
723 std::string weap_id_;
742 void check_replay_attack_result(
bool&,
int,
int&,
config, unit_info&);
747 std::unique_ptr<battle_context> bc_;
752 int abs_n_attack_, abs_n_defend_;
754 bool update_att_fog_, update_def_fog_, update_minimap_;
758 std::ostringstream errbuf_;
760 bool update_display_;
765 std::vector<bool> prng_attacker_;
766 std::vector<bool> prng_defender_;
786 id_ =
i->underlying_id();
789 unit& attack::unit_info::get_unit()
792 assert(
i.valid() &&
i->underlying_id() == id_);
796 unit_ptr attack::unit_info::get_unit_ptr()
799 if(
i.valid() &&
i->underlying_id() == id_) {
800 return i.get_shared_ptr();
805 bool attack::unit_info::valid()
808 return i.valid() &&
i->underlying_id() == id_;
811 std::string attack::unit_info::dump()
814 s << get_unit().type_id() <<
" (" << loc_.wml_x() <<
',' << loc_.wml_y() <<
')';
828 , update_att_fog_(false)
829 , update_def_fog_(false)
830 , update_minimap_(false)
835 , update_display_(update_display)
844 LOG_NG <<
"Using experimental PRNG for combat";
850 fire_event_impl(
n,
false);
853 void attack::fire_event_impl(
const std::string&
n,
bool reverse)
855 LOG_NG <<
"attack: firing '" <<
n <<
"' event";
863 utils::optional<attack_type::specials_context_t> a_ctx, d_ctx;
865 if(a_stats_->weapon !=
nullptr &&
a_.valid()) {
866 if(d_stats_->weapon !=
nullptr && d_.valid()) {
867 a_ctx.emplace(a_stats_->weapon->specials_context(
nullptr,
nullptr,
a_.loc_, d_.loc_,
true, d_stats_->weapon));
869 a_ctx.emplace(a_stats_->weapon->specials_context(
nullptr,
a_.loc_,
true));
871 a_stats_->weapon->write(a_weapon_cfg);
874 if(d_stats_->weapon !=
nullptr && d_.valid()) {
875 if(a_stats_->weapon !=
nullptr &&
a_.valid()) {
876 d_ctx.emplace(d_stats_->weapon->specials_context(
nullptr,
nullptr, d_.loc_,
a_.loc_,
false, a_stats_->weapon));
878 d_ctx.emplace(d_stats_->weapon->specials_context(
nullptr, d_.loc_,
false));
880 d_stats_->weapon->write(d_weapon_cfg);
883 if(a_weapon_cfg[
"name"].empty()) {
884 a_weapon_cfg[
"name"] =
"none";
887 if(d_weapon_cfg[
"name"].empty()) {
888 d_weapon_cfg[
"name"] =
"none";
891 if(
n ==
"attack_end") {
899 if(
n ==
"attacker_hits" ||
n ==
"defender_hits" ||
n ==
"unit_hits") {
903 const int defender_side = d_.get_unit().side();
914 if(wml_aborted || !
a_.valid() || !d_.valid()
919 if(update_display_) {
924 throw attack_end_exception();
928 void attack::refresh_bc()
932 refresh_weapon_index(
a_.weapon_,
a_.weap_id_,
a_.get_unit().attacks());
936 refresh_weapon_index(d_.weapon_, d_.weap_id_, d_.get_unit().attacks());
939 if(!
a_.valid() || !d_.valid()) {
942 =
a_.valid() &&
a_.weapon_ >= 0 ?
a_.get_unit().attacks()[
a_.weapon_].shared_from_this() :
nullptr;
945 = d_.valid() && d_.weapon_ >= 0 ? d_.get_unit().attacks()[d_.weapon_].shared_from_this() :
nullptr;
952 a_stats_ = &bc_->get_attacker_stats();
953 d_stats_ = &bc_->get_defender_stats();
955 a_.cth_ = a_stats_->chance_to_hit;
956 d_.cth_ = d_stats_->chance_to_hit;
957 a_.damage_ = a_stats_->damage;
958 d_.damage_ = d_stats_->damage;
963 unit_info& attacker = attacker_turn ?
a_ : d_;
964 unit_info& defender = attacker_turn ? d_ :
a_;
971 int& abs_n = attacker_turn ? abs_n_attack_ : abs_n_defend_;
972 bool& update_fog = attacker_turn ? update_def_fog_ : update_att_fog_;
978 std::vector<bool>& prng_seq = attacker_turn ? prng_attacker_ : prng_defender_;
980 if(prng_seq.empty()) {
981 const int ntotal = attacker.cth_*attacker.n_attacks_;
982 int num_hits = ntotal/100;
983 const int additional_hit_chance = ntotal%100;
984 if(additional_hit_chance > 0 &&
randomness::generator->get_random_int(0, 99) < additional_hit_chance) {
988 std::vector<int> indexes;
989 for(
int i = 0;
i != attacker.n_attacks_; ++
i) {
990 prng_seq.push_back(
false);
991 indexes.push_back(
i);
994 for(
int i = 0;
i != num_hits; ++
i) {
996 prng_seq[indexes[
n]] =
true;
997 indexes.erase(indexes.begin() +
n);
1001 bool does_hit = prng_seq.back();
1002 prng_seq.pop_back();
1003 ran_num = does_hit ? 0 : 99;
1007 bool hits = (ran_num < attacker.cth_);
1011 damage = attacker.damage_;
1017 const config local_results {
"chance", attacker.cth_,
"hits", hits,
"damage", damage};
1022 if(!equals_replay) {
1023 check_replay_attack_result(hits, ran_num, damage, replay_results, attacker);
1027 int damage_done = std::min<int>(defender.get_unit().hitpoints(), attacker.damage_);
1030 double expected_damage = damage_done * attacker.cth_ * 0.01;
1038 int drains_damage = 0;
1039 if(hits && attacker_stats->
drains) {
1044 std::min<int>(drains_damage, attacker.get_unit().max_hitpoints() - attacker.get_unit().hitpoints());
1047 drains_damage = std::max<int>(drains_damage, 1 - attacker.get_unit().hitpoints());
1050 if(update_display_) {
1051 std::ostringstream float_text;
1052 std::vector<std::string> extra_hit_sounds;
1055 const unit& defender_unit = defender.get_unit();
1076 if(
prefs::get().show_attack_miss_indicator()) {
1077 float_text <<
_(
"attack^miss");
1084 attacker.loc_, defender.loc_,
1087 abs_n, float_text.str(), drains_damage,
"",
1088 &extra_hit_sounds, attacker_turn
1092 bool dies = defender.get_unit().take_hit(damage);
1093 LOG_NG <<
"defender took " << damage << (dies ?
" and died\n" :
"\n");
1101 attacker.cth_, damage_done, drains_damage
1109 attacker.cth_, damage_done, drains_damage
1113 replay_results.
clear();
1118 if(!equals_replay) {
1119 bool results_dies = replay_results[
"dies"].to_bool();
1121 errbuf_ <<
"SYNC: In attack " <<
a_.dump() <<
" vs " << d_.dump() <<
": the data source says the "
1122 << (attacker_turn ?
"defender" :
"attacker") <<
' ' << (results_dies ?
"perished" :
"survived")
1123 <<
" while in-game calculations show it " << (dies ?
"perished" :
"survived")
1124 <<
" (over-riding game calculations with data source results)\n";
1126 dies = results_dies;
1130 defender.get_unit().set_hitpoints(0);
1138 fire_event(attacker_turn ?
"attacker_hits" :
"defender_hits");
1139 fire_event_impl(
"unit_hits", !attacker_turn);
1140 }
catch(
const attack_end_exception&) {
1146 fire_event(attacker_turn ?
"attacker_misses" :
"defender_misses");
1147 fire_event_impl(
"unit_misses", !attacker_turn);
1148 }
catch(
const attack_end_exception&) {
1156 bool attacker_dies =
false;
1158 if(drains_damage > 0) {
1159 attacker.get_unit().heal(drains_damage);
1160 }
else if(drains_damage < 0) {
1161 attacker_dies = attacker.get_unit().take_hit(-drains_damage);
1165 unit_killed(attacker, defender, attacker_stats, defender_stats,
false);
1170 unit_killed(defender, attacker, defender_stats, attacker_stats,
true);
1171 (attacker_turn ? update_att_fog_ : update_def_fog_) =
true;
1175 update_minimap_ =
true;
1180 unit& defender_unit = defender.get_unit();
1184 LOG_NG <<
"defender poisoned";
1191 LOG_NG <<
"defender slowed";
1198 attacker.n_attacks_ = 0;
1199 defender.n_attacks_ = -1;
1207 update_minimap_ =
true;
1211 --attacker.n_attacks_;
1215 if (attacker_stats->
weapon ==
nullptr){
1216 attacker.n_attacks_ = 0;
1217 attacker.orig_attacks_ = 0;
1219 if (defender_stats->
weapon ==
nullptr){
1220 defender.n_attacks_ = 0;
1221 defender.orig_attacks_ = 0;
1227 void attack::unit_killed(unit_info& attacker,
1228 unit_info& defender,
1241 std::string undead_variation = defender.get_unit().undead_variation();
1251 if(a_weapon_cfg[
"name"].empty()) {
1252 a_weapon_cfg[
"name"] =
"none";
1255 if(d_weapon_cfg[
"name"].empty()) {
1256 d_weapon_cfg[
"name"] =
"none";
1266 if(!defender.valid() || defender.get_unit().hitpoints() > 0) {
1270 if(!attacker.valid()) {
1273 defender.get_unit(),
1280 defender.get_unit(),
1284 attacker.get_unit_ptr()
1291 if(!defender.valid() || defender.get_unit().hitpoints() > 0) {
1296 units_.erase(defender.loc_);
1300 if(attacker.valid() && attacker_stats->
plagues && !drain_killed) {
1304 LOG_NG <<
"found unit type:" << reanimator->id();
1307 newunit->set_attacks(0);
1308 newunit->set_movement(0,
true);
1312 if(undead_variation !=
"null") {
1315 variation[
"apply_to"] =
"variation";
1316 variation[
"name"] = undead_variation;
1317 newunit->add_modification(
"variation", mod);
1318 newunit->heal_fully();
1321 newunit->set_location(death_loc);
1329 if(update_display_) {
1334 LOG_NG <<
"unit not reanimated";
1338 void attack::perform()
1343 if(!
a_.valid() || !d_.valid()) {
1348 if(
a_.weapon_ < 0) {
1349 a_.get_unit().set_attacks(
a_.get_unit().attacks_left() - 1);
1350 a_.get_unit().set_movement(-1,
true);
1354 if(
a_.get_unit().attacks_left() <= 0) {
1355 LOG_NG <<
"attack::perform(): not enough ap.";
1361 a_stats_ = &bc_->get_attacker_stats();
1362 d_stats_ = &bc_->get_defender_stats();
1364 if(a_stats_->weapon) {
1365 a_.weap_id_ = a_stats_->weapon->id();
1368 if(d_stats_->weapon) {
1369 d_.weap_id_ = d_stats_->weapon->id();
1372 a_.get_unit().set_facing(
a_.loc_.get_relative_dir(d_.loc_));
1373 d_.get_unit().set_facing(d_.loc_.get_relative_dir(
a_.loc_));
1377 }
catch(
const attack_end_exception&) {
1381 VALIDATE(
a_.weapon_ <
static_cast<int>(
a_.get_unit().attacks().size()),
1382 _(
"An invalid attacker weapon got selected."));
1384 a_.get_unit().set_attacks(
a_.get_unit().attacks_left() -
a_.get_unit().attacks()[
a_.weapon_].attacks_used());
1385 a_.get_unit().set_movement(
a_.get_unit().movement_left() -
a_.get_unit().attacks()[
a_.weapon_].movement_used(),
true);
1387 a_.get_unit().set_resting(
false);
1388 d_.get_unit().set_resting(
false);
1393 if(a_stats_->disable) {
1394 LOG_NG <<
"attack::perform(): tried to attack with a disabled attack.";
1400 }
catch(
const attack_end_exception&) {
1404 DBG_NG <<
"getting attack statistics";
1406 a_.get_unit(), d_.get_unit(), a_stats_->chance_to_hit, d_stats_->chance_to_hit);
1408 a_.orig_attacks_ = a_stats_->num_blows;
1409 d_.orig_attacks_ = d_stats_->num_blows;
1410 a_.n_attacks_ =
a_.orig_attacks_;
1411 d_.n_attacks_ = d_.orig_attacks_;
1415 bool defender_strikes_first = (d_stats_->firststrike && !a_stats_->firststrike);
1416 unsigned int rounds = std::max<unsigned int>(a_stats_->rounds, d_stats_->rounds) - 1;
1417 const int defender_side = d_.get_unit().side();
1419 LOG_NG <<
"Fight: (" <<
a_.loc_ <<
") vs (" << d_.loc_ <<
") ATT: " << a_stats_->weapon->name() <<
" "
1420 << a_stats_->damage <<
"-" << a_stats_->num_blows <<
"(" << a_stats_->chance_to_hit
1421 <<
"%) vs DEF: " << (d_stats_->weapon ? d_stats_->weapon->name() :
"none") <<
" " << d_stats_->damage <<
"-"
1422 << d_stats_->num_blows <<
"(" << d_stats_->chance_to_hit <<
"%)"
1423 << (defender_strikes_first ?
" defender first-strike" :
"");
1429 DBG_NG <<
"start of attack loop...";
1432 if(
a_.n_attacks_ > 0 && !defender_strikes_first) {
1433 if(!perform_hit(
true, attack_stats)) {
1434 DBG_NG <<
"broke from attack loop on attacker turn";
1440 defender_strikes_first =
false;
1443 if(d_.n_attacks_ > 0) {
1444 if(!perform_hit(
false, attack_stats)) {
1445 DBG_NG <<
"broke from attack loop on defender turn";
1452 if(rounds > 0 && d_.n_attacks_ == 0 &&
a_.n_attacks_ == 0) {
1453 a_.n_attacks_ =
a_.orig_attacks_;
1454 d_.n_attacks_ = d_.orig_attacks_;
1456 defender_strikes_first = (d_stats_->firststrike && !a_stats_->firststrike);
1459 if(
a_.n_attacks_ <= 0 && d_.n_attacks_ <= 0) {
1469 if(update_def_fog_) {
1474 if(update_minimap_ && update_display_) {
1485 unit& u = d_.get_unit();
1491 d_.loc_, d_.get_unit_ptr());
1493 if(update_display_) {
1504 void attack::check_replay_attack_result(
1505 bool& hits,
int ran_num,
int& damage,
config replay_results, unit_info& attacker)
1507 int results_chance = replay_results[
"chance"].to_int();
1508 bool results_hits = replay_results[
"hits"].to_bool();
1509 int results_damage = replay_results[
"damage"].to_int();
1512 errbuf_ <<
"SYNC: In attack " <<
a_.dump() <<
" vs " << d_.dump()
1513 <<
" replay data differs from local calculated data:"
1514 <<
" chance to hit in data source: " << results_chance
1515 <<
" chance to hit in calculated: " << attacker.cth_
1516 <<
" chance to hit in data source: " << results_chance
1517 <<
" chance to hit in calculated: " << attacker.cth_
1520 attacker.cth_ = results_chance;
1521 hits = results_hits;
1522 damage = results_damage;
1527 if(results_chance != attacker.cth_) {
1528 errbuf_ <<
"SYNC: In attack " <<
a_.dump() <<
" vs " << d_.dump()
1529 <<
": chance to hit is inconsistent. Data source: " << results_chance
1530 <<
"; Calculation: " << attacker.cth_ <<
" (over-riding game calculations with data source results)\n";
1531 attacker.cth_ = results_chance;
1535 if(results_hits != hits) {
1536 errbuf_ <<
"SYNC: In attack " <<
a_.dump() <<
" vs " << d_.dump() <<
": the data source says the hit was "
1537 << (results_hits ?
"successful" :
"unsuccessful") <<
", while in-game calculations say the hit was "
1538 << (hits ?
"successful" :
"unsuccessful") <<
" random number: " << ran_num <<
" = " << (ran_num % 100)
1539 <<
"/" << results_chance <<
" (over-riding game calculations with data source results)\n";
1540 hits = results_hits;
1544 if(results_damage != damage) {
1545 errbuf_ <<
"SYNC: In attack " <<
a_.dump() <<
" vs " << d_.dump() <<
": the data source says the hit did "
1546 << results_damage <<
" damage, while in-game calculations show the hit doing " << damage
1547 <<
" damage (over-riding game calculations with data source results)\n";
1548 damage = results_damage;
1563 bool update_display)
1565 attack
dummy(attacker, defender, attack_with, defend_with, update_display);
1573 bool update_display)
1575 attack_unit(attacker, defender, attack_with, defend_with, update_display);
1620 case unit_alignments::type::lawful:
1621 bonus = lawful_bonus;
1623 case unit_alignments::type::neutral:
1626 case unit_alignments::type::chaotic:
1627 bonus = -lawful_bonus;
1629 case unit_alignments::type::liminal:
1630 bonus = max_liminal_bonus-std::abs(lawful_bonus);
1637 bonus = std::max<int>(bonus, 0);
1646 const std::vector<team>& teams)
1649 if(defender == units.
end()) {
1656 for(
i = 0;
i < adj.size(); ++
i) {
1657 if(adj[
i] == attacker_loc) {
1669 if(opp == units.
end()) {
1673 if(opp->incapacitated()) {
1678 if(std::size_t(defender->side() - 1) >= teams.size() || std::size_t(opp->side() - 1) >= teams.size()) {
1683 if(teams[defender->side() - 1].is_enemy(opp->side())) {
int under_leadership(const unit &u, const map_location &loc, const_attack_ptr weapon, const_attack_ptr opp_weapon)
Tests if the unit at loc is currently affected by leadership.
int generic_combat_modifier(int lawful_bonus, unit_alignments::type alignment, bool is_fearless, int max_liminal_bonus)
Returns the amount that a unit's damage should be multiplied by due to a given lawful_bonus.
static lg::log_domain log_engine("engine")
bool backstab_check(const map_location &attacker_loc, const map_location &defender_loc, const unit_map &units, const std::vector< team > &teams)
Function to check if an attack will satisfy the requirements for backstab.
int combat_modifier(const unit_map &units, const gamemap &map, const map_location &loc, unit_alignments::type alignment, bool is_fearless)
Returns the amount that a unit's damage should be multiplied by due to the current time of day.
void attack_unit_and_advance(const map_location &attacker, const map_location &defender, int attack_with, int defend_with, bool update_display)
Performs an attack, and advanced the units afterwards.
void attack_unit(const map_location &attacker, const map_location &defender, int attack_with, int defend_with, bool update_display)
Performs an attack.
static lg::log_domain log_attack("engine/attack")
static lg::log_domain log_config("config")
Various functions that implement attacks and attack calculations.
void advance_unit_at(const advance_unit_params ¶ms)
Various functions that implement advancements of units.
boost::iterator_range< boost::indirect_iterator< attack_list::iterator > > attack_itors
double defense_weight() const
double attack_weight() const
const std::string & range() const
Computes the statistics of a battle between an attacker and a defender unit.
std::unique_ptr< battle_context_unit_stats > defender_stats_
std::unique_ptr< combatant > defender_combatant_
std::unique_ptr< battle_context_unit_stats > attacker_stats_
Statistics of the units.
static battle_context choose_attacker_weapon(nonempty_unit_const_ptr attacker, const nonempty_unit_const_ptr &defender, const map_location &attacker_loc, const map_location &defender_loc, double harm_weight, const combatant *prev_def)
std::unique_ptr< combatant > attacker_combatant_
Outcome of simulated fight.
void simulate(const combatant *prev_def)
const combatant & get_attacker_combatant(const combatant *prev_def=nullptr)
Get the simulation results.
const combatant & get_defender_combatant(const combatant *prev_def=nullptr)
static bool better_combat(const combatant &us_a, const combatant &them_a, const combatant &us_b, const combatant &them_b, double harm_weight)
static battle_context choose_defender_weapon(nonempty_unit_const_ptr attacker, nonempty_unit_const_ptr defender, unsigned attacker_weapon, const map_location &attacker_loc, const map_location &defender_loc, const combatant *prev_def)
battle_context(const unit_map &units, const map_location &attacker_loc, const map_location &defender_loc, int attacker_weapon=-1, int defender_weapon=-1, double aggression=0.0, const combatant *prev_def=nullptr, unit_const_ptr attacker_ptr=unit_const_ptr(), unit_const_ptr defender_ptr=unit_const_ptr())
If no attacker_weapon is given, we select the best one, based on harm_weight (1.0 means 1 hp lost cou...
bool better_defense(class battle_context &that, double harm_weight)
Given this harm_weight, is this attack better than that?
bool better_attack(class battle_context &that, double harm_weight)
Given this harm_weight, is this attack better than that?
virtual bool local_checkup(const config &expected_data, config &real_data)=0
Compares data to the results calculated during the original game.
A config object defines a single node in a WML file, with access to child nodes.
void insert(config_key_type key, T &&value)
Inserts an attribute into the config.
config & add_child(config_key_type key)
void redraw_minimap()
Schedule the minimap to be redrawn.
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
static display * get_singleton()
Returns the display object if a display object exists.
virtual const unit_map & units() const override
virtual const gamemap & map() const override
void clear_variable(const std::string &varname)
Clears attributes config children does nothing if varname is no valid variable name.
config::attribute_value & get_variable(const std::string &varname)
throws invalid_variablename_exception if varname is no valid variable name.
void invalidate_unit()
Function to invalidate that unit status displayed on the sidebar.
static game_display * get_singleton()
game_events::wml_event_pump & pump()
pump_result_t fire(const std::string &event, const entity_location &loc1=entity_location::null_entity, const entity_location &loc2=entity_location::null_entity, const config &data=config())
Function to fire an event.
terrain_code get_terrain(const map_location &loc) const
Looks up terrain at a particular location.
Encapsulates the map of the game.
bool is_village(const map_location &loc) const
std::set< std::string > & encountered_units()
int get_random_int(int min, int max)
static void process_error(const std::string &msg)
bool is_enemy(int n) const
int get_max_liminal_bonus() const
time_of_day get_illuminated_time_of_day(const unit_map &units, const gamemap &map, const map_location &loc, int for_turn=0) const
Returns time of day object for the passed turn at a location.
int get_composite_value() const
void set_standing(bool with_bars=true)
Sets the animation state to standing.
Container associating units to locations.
unit_iterator find(std::size_t id)
const unit_type * find(const std::string &key, unit_type::BUILD_STATUS status=unit_type::FULL) const
Finds a unit_type by its id() and makes sure it is built to the specified level.
A single unit type that the player may recruit.
const std::string & parent_id() const
The id of the original type from which this (variation) descended.
int resistance_against(const std::string &damage_name, bool attacker) const
Gets resistance while considering custom WML abilities.
int experience_needed(bool with_acceleration=true) const
bool musthave_status(const std::string &status) const
const std::string & undead_variation() const
Info on the type of unit that the unit reanimates as.
unit_alignments::type alignment() const
This class represents a single unit of a specific type.
static unit_ptr create(const config &cfg, bool use_traits=false, const vconfig *vcfg=nullptr)
Initializes a unit from a config.
static std::string _(const char *str)
unit_ability_list get_abilities_weapons(const std::string &tag_name, const map_location &loc, const_attack_ptr weapon=nullptr, const_attack_ptr opp_weapon=nullptr) const
int max_hitpoints() const
The max number of hitpoints this unit can have.
unit_alignments::type alignment() const
The alignment of this unit.
void set_state(const std::string &state, bool value)
Set whether the unit is affected by a status effect.
int hitpoints() const
The current number of hitpoints this unit has.
bool get_state(const std::string &state) const
Check if the unit is affected by a status effect.
const std::string & undead_variation() const
const unit_type & type() const
This unit's type, accounting for gender and variation.
int experience() const
The current number of experience points this unit has.
void set_experience(int xp)
Sets the current experience point amount.
unit_race::GENDER gender() const
The gender of this unit.
@ STATE_NOT_MOVED
The unit is uncovered - it was hiding but has been spotted.
@ STATE_PETRIFIED
The unit is poisoned - it loses health each turn.
@ STATE_POISONED
The unit is slowed - it moves slower and does less damage.
@ STATE_UNCOVERED
The unit is petrified - it cannot move or be attacked.
int damage_from(const attack_type &attack, bool attacker, const map_location &loc, const_attack_ptr weapon=nullptr) const
Calculates the damage this unit would take from a certain attack.
int defense_modifier(const t_translation::terrain_code &terrain) const
The unit's defense on a given terrain.
attack_itors attacks()
Gets an iterator over this unit's attacks.
unit_animation_component & anim_comp() const
bool is_fearless() const
Gets whether this unit is fearless - ie, unaffected by time of day.
std::size_t distance_between(const map_location &a, const map_location &b)
Function which gives the number of hexes between two tiles (i.e.
void get_adjacent_tiles(const map_location &a, utils::span< map_location, 6 > res)
Function which, given a location, will place all adjacent locations in res.
Standard logging facilities (interface).
#define log_scope2(domain, description)
constexpr int round_damage(double base_damage, int bonus, int divisor)
round (base_damage * bonus / divisor) to the closest integer, but up or down towards base_damage
void recalculate_fog(int side)
Function that recalculates the fog of war.
bool fire_event(const ui_event event, const std::vector< std::pair< widget *, ui_event >> &event_chain, widget *dispatcher, widget *w, F &&... params)
Helper function for fire_event.
rng * generator
This generator is automatically synced during synced context.
::tod_manager * tod_manager
game_events::manager * game_events
game_classification * classification
play_controller * controller
std::shared_ptr< wb::manager > whiteboard
void unit_die(const map_location &loc, unit &loser, const const_attack_ptr &attack, const const_attack_ptr &secondary_attack, const map_location &winner_loc, const unit_ptr &winner)
Show a unit fading out.
void unit_draw_weapon(const map_location &loc, unit &attacker, const const_attack_ptr &attack, const const_attack_ptr &secondary_attack, const map_location &defender_loc, const unit_ptr &defender)
Play a pre-fight animation First unit is the attacker, second unit the defender.
void unit_attack(display *disp, game_board &board, const map_location &a, const map_location &b, int damage, const attack_type &attack, const const_attack_ptr &secondary_attack, int swing, const std::string &hit_text, int drain_amount, const std::string &att_text, const std::vector< std::string > *extra_hit_sounds, bool attacking)
Make the unit on tile 'a' attack the unit on tile 'b'.
void unit_sheath_weapon(const map_location &primary_loc, const unit_ptr &primary_unit, const const_attack_ptr &primary_attack, const const_attack_ptr &secondary_attack, const map_location &secondary_loc, const unit_ptr &secondary_unit)
Play a post-fight animation Both unit can be set to null, only valid units will play their animation.
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
std::shared_ptr< const unit > unit_const_ptr
std::shared_ptr< const attack_type > const_attack_ptr
std::shared_ptr< unit > unit_ptr
Define the game's event mechanism.
advances the unit at loc if it has enough experience, maximum 20 times.
Structure describing the statistics of a unit involved in the battle.
bool slows
Attack slows opponent when it hits.
unsigned int num_blows
Effective number of blows, takes swarm into account.
std::string plague_type
The plague type used by the attack, if any.
battle_context_unit_stats(nonempty_unit_const_ptr u, const map_location &u_loc, int u_attack_num, bool attacking, nonempty_unit_const_ptr opp, const map_location &opp_loc, const const_attack_ptr &opp_weapon)
bool petrifies
Attack petrifies opponent when it hits.
int drain_percent
Percentage of damage recovered as health.
unsigned int hp
Hitpoints of the unit at the beginning of the battle.
int slow_damage
Effective damage if unit becomes slowed (== damage, if already slowed)
unsigned int max_experience
bool drains
Attack drains opponent when it hits.
unsigned int swarm_min
Minimum number of blows with swarm (equal to num_blows if swarm isn't used).
bool swarm
Attack has swarm special.
const_attack_ptr weapon
The weapon used by the unit to attack the opponent, or nullptr if there is none.
bool is_slowed
True if the unit is slowed at the beginning of the battle.
unsigned int rounds
Berserk special can force us to fight more than one round.
unsigned int swarm_max
Maximum number of blows with swarm (equal to num_blows if swarm isn't used).
unsigned int calc_blows(unsigned new_hp) const
Calculates the number of blows we would have if we had new_hp instead of the recorded hp.
unsigned int max_hp
Maximum hitpoints of the unit.
int damage
Effective damage of the weapon (all factors accounted for).
bool disable
Attack has disable special.
bool poisons
Attack poisons opponent when it hits.
unsigned int chance_to_hit
Effective chance to hit as a percentage (all factors accounted for).
int drain_constant
Base HP drained regardless of damage dealt.
bool firststrike
Attack has firststrike special.
int attack_num
Index into unit->attacks() or -1 for none.
bool plagues
Attack turns opponent into a zombie when fatal.
std::vector< double > hp_dist
Resulting probability distribution (might be not as large as max_hp)
double poisoned
Resulting chance we are poisoned.
const battle_context_unit_stats & u_
double average_hp(unsigned int healing=0) const
What's the average hp (weighted average of hp_dist).
Encapsulates the map of the game.
static constexpr direction get_opposite_direction(direction d)
static const map_location & null_location()
void attack_result(hit_result res, int cth, int damage, int drain)
void attack_expected_damage(double attacker_inflict, double defender_inflict)
void defend_result(hit_result res, int cth, int damage, int drain)
Object which defines a time of day with associated bonuses, image, sounds etc.
int lawful_bonus
The % bonus lawful units receive.
const config * ability_cfg
The contents of the ability tag, never nullptr.
pointer get_shared_ptr() const
This is exactly the same as operator-> but it's slightly more readable, and can replace &*iter syntax...
checkup * checkup_instance
static map_location::direction n
static map_location::direction s
unit_type_data unit_types
Display units performing various actions: moving, attacking, and dying.
Various functions implementing vision (through fog of war and shroud).
Add a special kind of assert to validate whether the input from WML doesn't contain any problems that...
#define VALIDATE(cond, message)
The macro to use for the validation of WML.