static std::string format_stats(const unit& u)
{
const std::string name = "<span size='large'>" + (!u.name().empty() ? u.name() : " ") + "</span>";
std::string traits;
BOOST_FOREACH(const std::string& trait, u.get_traits_list()) {
traits += (traits.empty() ? "" : ", ") + trait;
}
if (traits.empty()) {
traits = " ";
}
std::stringstream str;
str << name << "\n";
str << "<small>";
str << "<span color='#f5e6c1'>" << u.type_name() << "</span>" << "\n";
str << "Lvl " << u.level() << "\n";
str << u.alignment() << "\n";
str << traits << "\n";
str << font::span_color(u.hp_color())
<< _("HP: ") << u.hitpoints() << "/" << u.max_hitpoints() << "</span>" << "\n";
str << font::span_color(u.xp_color())
<< _("XP: ") << u.experience() << "/" << u.max_experience() << "</span>" << "\n";
str << "</small>" << "\n";
return str.str();
}
battle_context_unit_stats::battle_context_unit_stats(const unit &u,
const map_location& u_loc, int u_attack_num, bool attacking,
const unit &opp, const map_location& opp_loc,
const attack_type *opp_weapon, const unit_map& units) :
weapon(NULL),
attack_num(u_attack_num),
is_attacker(attacking),
is_poisoned(u.get_state(unit::STATE_POISONED)),
is_slowed(u.get_state(unit::STATE_SLOWED)),
slows(false),
drains(false),
petrifies(false),
plagues(false),
poisons(false),
backstab_pos(false),
swarm(false),
firststrike(false),
experience(u.experience()),
max_experience(u.max_experience()),
level(u.level()),
rounds(1),
hp(0),
max_hp(u.max_hitpoints()),
chance_to_hit(0),
damage(0),
slow_damage(0),
drain_percent(0),
drain_constant(0),
num_blows(0),
swarm_min(0),
swarm_max(0),
plague_type()
{
// Get the current state of the unit.
if (attack_num >= 0) {
weapon = &u.attacks()[attack_num];
}
if(u.hitpoints() < 0) {
LOG_CF << "Unit with " << u.hitpoints() << " hitpoints found, set to 0 for damage calculations\n";
hp = 0;
} else if(u.hitpoints() > u.max_hitpoints()) {
// If a unit has more hp than its maximum, the engine will fail
// with an assertion failure due to accessing the prob_matrix
// out of bounds.
hp = u.max_hitpoints();
} else {
hp = u.hitpoints();
}
// Get the weapon characteristics, if any.
if (weapon) {
weapon->set_specials_context(u_loc, opp_loc, attacking, opp_weapon);
if (opp_weapon)
opp_weapon->set_specials_context(opp_loc, u_loc, !attacking, weapon);
slows = weapon->get_special_bool("slow");
drains = !opp.get_state("undrainable") && weapon->get_special_bool("drains");
petrifies = weapon->get_special_bool("petrifies");
poisons = !opp.get_state("unpoisonable") && weapon->get_special_bool("poison") && !opp.get_state(unit::STATE_POISONED);
backstab_pos = is_attacker && backstab_check(u_loc, opp_loc, units, *resources::teams);
rounds = weapon->get_specials("berserk").highest("value", 1).first;
firststrike = weapon->get_special_bool("firststrike");
// Handle plague.
unit_ability_list plague_specials = weapon->get_specials("plague");
plagues = !opp.get_state("unplagueable") && !plague_specials.empty() &&
strcmp(opp.undead_variation().c_str(), "null") && !resources::game_map->is_village(opp_loc);
if (plagues) {
plague_type = (*plague_specials.front().first)["type"].str();
if (plague_type.empty())
plague_type = u.type().base_id();
}
// Compute chance to hit.
chance_to_hit = opp.defense_modifier(
resources::game_map->get_terrain(opp_loc)) + weapon->accuracy() -
(opp_weapon ? opp_weapon->parry() : 0);
if(chance_to_hit > 100) {
chance_to_hit = 100;
}
unit_ability_list cth_specials = weapon->get_specials("chance_to_hit");
unit_abilities::effect cth_effects(cth_specials, chance_to_hit, backstab_pos);
chance_to_hit = cth_effects.get_composite_value();
// Compute base damage done with the weapon.
int base_damage = weapon->modified_damage(backstab_pos);
// Get the damage multiplier applied to the base damage of the weapon.
int damage_multiplier = 100;
// Time of day bonus.
damage_multiplier += combat_modifier(u_loc, u.alignment(), u.is_fearless());
// Leadership bonus.
int leader_bonus = 0;
if (under_leadership(units, u_loc, &leader_bonus).valid())
damage_multiplier += leader_bonus;
// Resistance modifier.
damage_multiplier *= opp.damage_from(*weapon, !attacking, opp_loc);
// Compute both the normal and slowed damage.
damage = round_damage(base_damage, damage_multiplier, 10000);
slow_damage = round_damage(base_damage, damage_multiplier, 20000);
if (is_slowed)
damage = slow_damage;
// Compute drain amounts only if draining is possible.
if(drains) {
unit_ability_list drain_specials = weapon->get_specials("drains");
// Compute the drain percent (with 50% as the base for backward compatibility)
unit_abilities::effect drain_percent_effects(drain_specials, 50, backstab_pos);
drain_percent = drain_percent_effects.get_composite_value();
}
// Add heal_on_hit (the drain constant)
unit_ability_list heal_on_hit_specials = weapon->get_specials("heal_on_hit");
unit_abilities::effect heal_on_hit_effects(heal_on_hit_specials, 0, backstab_pos);
drain_constant += heal_on_hit_effects.get_composite_value();
drains = drain_constant || drain_percent;
// Compute the number of blows and handle swarm.
weapon->modified_attacks(backstab_pos, swarm_min, swarm_max);
swarm = swarm_min != swarm_max;
num_blows = calc_blows(hp);
}
}
void tunit_preview_pane::set_displayed_unit(const unit& u)
{
// Sets the current type id for the profile button callback to use
current_type_ = u.type_id();
if(icon_type_) {
std::string mods = u.image_mods();
if(u.can_recruit()) {
mods += "~BLIT(" + unit::leader_crown() + ")";
}
for(const std::string& overlay : u.overlays()) {
mods += "~BLIT(" + overlay + ")";
}
mods += "~SCALE_INTO_SHARP(144,144)" + image_mods_;
icon_type_->set_label(u.absolute_image() + mods);
}
if(label_name_) {
std::string name;
if(!u.name().empty()) {
name = "<span size='large'>" + u.name() + "</span>" + "\n" + "<small><span color='#a69275'>" + u.type_name() + "</span></small>";
} else {
name = "<span size='large'>" + u.type_name() + "</span>\n";
}
label_name_->set_label(name);
label_name_->set_use_markup(true);
}
if(label_level_) {
std::string l_str = vgettext("Lvl $lvl", {{"lvl", std::to_string(u.level())}});
label_level_->set_label("<b>" + l_str + "</b>");
label_level_->set_use_markup(true);
}
if(icon_race_) {
icon_race_->set_label("icons/unit-groups/race_" + u.race()->id() + "_30.png");
icon_race_->set_tooltip(u.race()->name(u.gender()));
}
if(icon_alignment_) {
const std::string& alignment_name = u.alignment().to_string();
icon_alignment_->set_label("icons/alignments/alignment_" + alignment_name + "_30.png");
icon_alignment_->set_tooltip(unit_type::alignment_description(
u.alignment(),
u.gender()));
}
if(label_details_minimal_) {
std::stringstream str;
const std::string name = "<span size='large'>" + (!u.name().empty() ? u.name() : " ") + "</span>";
str << name << "\n";
str << "<span color='#a69275'>" << u.type_name() << "</span>" << "\n";
str << "Lvl " << u.level() << "\n";
str << u.alignment() << "\n";
str << utils::join(u.trait_names(), ", ") << "\n";
str << font::span_color(u.hp_color())
<< _("HP: ") << u.hitpoints() << "/" << u.max_hitpoints() << "</span>" << "\n";
str << font::span_color(u.xp_color())
<< _("XP: ") << u.experience() << "/" << u.max_experience() << "</span>";
label_details_minimal_->set_label(str.str());
label_details_minimal_->set_use_markup(true);
}
if(tree_details_) {
std::stringstream str;
str << "<small>";
str << font::span_color(u.hp_color())
<< "<b>" << _("HP: ") << "</b>" << u.hitpoints() << "/" << u.max_hitpoints() << "</span>" << " | ";
str << font::span_color(u.xp_color())
<< "<b>" << _("XP: ") << "</b>" << u.experience() << "/" << u.max_experience() << "</span>" << " | ";
str << "<b>" << _("MP: ") << "</b>"
<< u.movement_left() << "/" << u.total_movement();
str << "</small>";
tree_details_->clear();
add_name_tree_node(
tree_details_->get_root_node(),
"item",
str.str()
);
if (!u.trait_names().empty()) {
auto& header_node = add_name_tree_node(
tree_details_->get_root_node(),
"header",
"<b>" + _("Traits") + "</b>"
);
assert(u.trait_names().size() == u.trait_descriptions().size());
for (size_t i = 0; i < u.trait_names().size(); ++i) {
add_name_tree_node(
header_node,
"item",
u.trait_names()[i],
u.trait_descriptions()[i]
);
}
}
if (!u.get_ability_list().empty()) {
auto& header_node = add_name_tree_node(
tree_details_->get_root_node(),
"header",
"<b>" + _("Abilities") + "</b>"
);
for (const auto& ab : u.ability_tooltips()) {
add_name_tree_node(
header_node,
"item",
std::get<1>(ab),
std::get<2>(ab)
);
}
}
print_attack_details(u.attacks(), tree_details_->get_root_node());
}
}
void battle_prediction_pane::get_unit_strings(const battle_context_unit_stats& stats,
const unit& u, const map_location& u_loc, float u_unscathed,
const unit& opp, const map_location& opp_loc, const attack_type *opp_weapon,
std::vector<std::string>& left_strings, std::vector<std::string>& right_strings,
int& left_strings_width, int& right_strings_width, int& strings_width)
{
std::stringstream str;
char str_buf[10];
// With a weapon.
if(stats.weapon != NULL) {
// Set specials context (for safety, it should not have changed normally).
const attack_type *weapon = stats.weapon;
weapon->set_specials_context(u_loc, opp_loc, stats.is_attacker, opp_weapon);
// Get damage modifiers.
unit_ability_list dmg_specials = weapon->get_specials("damage");
unit_abilities::effect dmg_effect(dmg_specials, weapon->damage(), stats.backstab_pos);
// Get the SET damage modifier, if any.
const unit_abilities::individual_effect *set_dmg_effect = NULL;
unit_abilities::effect::const_iterator i;
for(i = dmg_effect.begin(); i != dmg_effect.end(); ++i) {
if(i->type == unit_abilities::SET) {
set_dmg_effect = &*i;
break;
}
}
// Either user the SET modifier or the base weapon damage.
if(set_dmg_effect == NULL) {
left_strings.push_back(weapon->name());
str.str("");
str << weapon->damage();
right_strings.push_back(str.str());
} else {
assert(set_dmg_effect->ability);
left_strings.push_back((*set_dmg_effect->ability)["name"]);
str.str("");
str << set_dmg_effect->value;
right_strings.push_back(str.str());
}
// Process the ADD damage modifiers.
for(i = dmg_effect.begin(); i != dmg_effect.end(); ++i) {
if(i->type == unit_abilities::ADD) {
left_strings.push_back((*i->ability)["name"]);
str.str("");
if(i->value >= 0) str << "+" << i->value;
else str << i->value;
right_strings.push_back(str.str());
}
}
// Process the MUL damage modifiers.
for(i = dmg_effect.begin(); i != dmg_effect.end(); ++i) {
if(i->type == unit_abilities::MUL) {
left_strings.push_back((*i->ability)["name"]);
str.str("");
str << "* " << (i->value / 100);
if(i->value % 100) {
str << "." << ((i->value % 100) / 10);
if(i->value % 10) str << (i->value % 10);
}
right_strings.push_back(str.str());
}
}
// Time of day modifier.
int tod_modifier = combat_modifier(resources::gameboard->units(), resources::gameboard->map(), u_loc, u.alignment(), u.is_fearless());
if(tod_modifier != 0) {
left_strings.push_back(_("Time of day"));
str.str("");
str << utils::signed_percent(tod_modifier);
right_strings.push_back(str.str());
}
// Leadership bonus.
int leadership_bonus = 0;
under_leadership(*resources::units, u_loc, &leadership_bonus);
if(leadership_bonus != 0) {
left_strings.push_back(_("Leadership"));
str.str("");
str << utils::signed_percent(leadership_bonus);
right_strings.push_back(str.str());
}
// Resistance modifier.
int resistance_modifier = opp.damage_from(*weapon, !stats.is_attacker, opp_loc);
if(resistance_modifier != 100) {
str.str("");
if(stats.is_attacker) str << _("Defender");
else str << _("Attacker");
if(resistance_modifier < 100) str << _(" resistance vs ");
else str << _(" vulnerability vs ");
str << string_table["type_" + weapon->type()];
left_strings.push_back(str.str());
str.str("");
str << "* " << (resistance_modifier / 100) << "." << ((resistance_modifier % 100) / 10);
right_strings.push_back(str.str());
}
// Slowed penalty.
if(stats.is_slowed) {
left_strings.push_back(_("Slowed"));
right_strings.push_back("/ 2");
}
// Total damage.
left_strings.push_back(_("Total damage"));
str.str("");
str << stats.damage << utils::unicode_en_dash << stats.num_blows << " (" << stats.chance_to_hit << "%)";
right_strings.push_back(str.str());
// Without a weapon.
} else {
left_strings.push_back(_("No usable weapon"));
right_strings.push_back("");
}
// Unscathed probability.
left_strings.push_back(_("Chance of being unscathed"));
format_prob(str_buf, u_unscathed);
right_strings.push_back(str_buf);
#if 0 // might not be in English!
// Fix capitalization of left strings.
for(int i = 0; i < (int) left_strings.size(); i++)
if(left_strings[i].size() > 0) left_strings[i][0] = toupper(left_strings[i][0]);
#endif
// Compute the width of the strings.
left_strings_width = get_strings_max_length(left_strings);
right_strings_width = get_strings_max_length(right_strings);
strings_width = left_strings_width + inter_column_gap_ + right_strings_width;
}
static int attack_info(reports::context & rc, const attack_type &at, config &res, const unit &u, const map_location &displayed_unit_hex)
{
std::ostringstream str, tooltip;
at.set_specials_context(displayed_unit_hex, u.side() == rc.screen().playing_side());
int base_damage = at.damage();
int specials_damage = at.modified_damage(false);
int damage_multiplier = 100;
int tod_bonus = combat_modifier(rc.units(), rc.map(), displayed_unit_hex, u.alignment(), u.is_fearless());
damage_multiplier += tod_bonus;
int leader_bonus = 0;
if (under_leadership(rc.units(), displayed_unit_hex, &leader_bonus).valid())
damage_multiplier += leader_bonus;
bool slowed = u.get_state(unit::STATE_SLOWED);
int damage_divisor = slowed ? 20000 : 10000;
// Assume no specific resistance (i.e. multiply by 100).
int damage = round_damage(specials_damage, damage_multiplier * 100, damage_divisor);
// Hit points are used to calculate swarm, so they need to be bounded.
unsigned max_hp = u.max_hitpoints();
unsigned cur_hp = std::min<unsigned>(std::max(0, u.hitpoints()), max_hp);
unsigned base_attacks = at.num_attacks();
unsigned min_attacks, max_attacks;
at.modified_attacks(false, min_attacks, max_attacks);
unsigned num_attacks = swarm_blows(min_attacks, max_attacks, cur_hp, max_hp);
SDL_Color dmg_color = font::weapon_color;
if ( damage > specials_damage )
dmg_color = font::good_dmg_color;
else if ( damage < specials_damage )
dmg_color = font::bad_dmg_color;
str << span_color(dmg_color) << " " << damage << naps << span_color(font::weapon_color)
<< font::weapon_numbers_sep << num_attacks << ' ' << at.name()
<< "</span>\n";
tooltip << _("Weapon: ") << "<b>" << at.name() << "</b>\n"
<< _("Damage: ") << "<b>" << damage << "</b>\n";
if ( tod_bonus || leader_bonus || slowed || specials_damage != base_damage )
{
tooltip << '\t' << _("Base damage: ") << base_damage << '\n';
if ( specials_damage != base_damage ) {
tooltip << '\t' << _("With specials: ") << specials_damage << '\n';
}
if (tod_bonus) {
tooltip << '\t' << _("Time of day: ")
<< utils::signed_percent(tod_bonus) << '\n';
}
if (leader_bonus) {
tooltip << '\t' << _("Leadership: ")
<< utils::signed_percent(leader_bonus) << '\n';
}
if (slowed) {
tooltip << '\t' << _("Slowed: ") << "/ 2" << '\n';
}
}
tooltip << _("Attacks: ") << "<b>" << num_attacks << "</b>\n";
if ( max_attacks != min_attacks && cur_hp != max_hp ) {
if ( max_attacks < min_attacks ) {
// "Reverse swarm"
tooltip << '\t' << _("Max swarm bonus: ") << (min_attacks-max_attacks) << '\n';
tooltip << '\t' << _("Swarm: ") << "* "<< (100 - cur_hp*100/max_hp) << "%\n";
tooltip << '\t' << _("Base attacks: ") << '+' << base_attacks << '\n';
// The specials line will not necessarily match up with how the
// specials are calculated, but for an unusual case, simple brevity
// trumps complexities.
if ( max_attacks != base_attacks ) {
int attack_diff = int(max_attacks) - int(base_attacks);
tooltip << '\t' << _("Specials: ") << utils::signed_value(attack_diff) << '\n';
}
}
else {
// Regular swarm
tooltip << '\t' << _("Base attacks: ") << base_attacks << '\n';
if ( max_attacks != base_attacks ) {
tooltip << '\t' << _("With specials: ") << max_attacks << '\n';
}
if ( min_attacks != 0 ) {
tooltip << '\t' << _("Subject to swarm: ") << (max_attacks-min_attacks) << '\n';
}
tooltip << '\t' << _("Swarm: ") << "* "<< (cur_hp*100/max_hp) << "%\n";
}
}
else if ( num_attacks != base_attacks ) {
tooltip << '\t' << _("Base attacks: ") << base_attacks << '\n';
tooltip << '\t' << _("With specials: ") << num_attacks << '\n';
}
add_text(res, flush(str), flush(tooltip));
std::string range = string_table["range_" + at.range()];
std::string lang_type = string_table["type_" + at.type()];
str << span_color(font::weapon_details_color) << " " << " "
<< range << font::weapon_details_sep
<< lang_type << "</span>\n";
tooltip << _("Weapon range: ") << "<b>" << range << "</b>\n"
<< _("Damage type: ") << "<b>" << lang_type << "</b>\n"
<< _("Damage versus: ") << '\n';
// Show this weapon damage and resistance against all the different units.
// We want weak resistances (= good damage) first.
std::map<int, std::set<std::string>, std::greater<int> > resistances;
std::set<std::string> seen_types;
const team &unit_team = rc.teams()[u.side() - 1];
const team &viewing_team = rc.teams()[rc.screen().viewing_team()];
for (const unit &enemy : rc.units())
{
if (enemy.incapacitated()) //we can't attack statues so don't display them in this tooltip
continue;
if (!unit_team.is_enemy(enemy.side()))
continue;
const map_location &loc = enemy.get_location();
if (viewing_team.fogged(loc) ||
(viewing_team.is_enemy(enemy.side()) && enemy.invisible(loc)))
continue;
bool new_type = seen_types.insert(enemy.type_id()).second;
if (new_type) {
int resistance = enemy.resistance_against(at, false, loc);
resistances[resistance].insert(enemy.type_name());
}
}
typedef std::pair<int, std::set<std::string> > resist_units;
for (const resist_units &resist : resistances) {
int damage = round_damage(specials_damage, damage_multiplier * resist.first, damage_divisor);
tooltip << "<b>" << damage << "</b> "
<< "<i>(" << utils::signed_percent(resist.first-100) << ")</i> : "
<< utils::join(resist.second, ", ") << '\n';
}
add_text(res, flush(str), flush(tooltip));
const std::string &accuracy_parry = at.accuracy_parry_description();
if (!accuracy_parry.empty())
{
str << span_color(font::weapon_details_color)
<< " " << accuracy_parry << "</span>\n";
int accuracy = at.accuracy();
if (accuracy) {
tooltip << _("Accuracy:") << "<b>"
<< utils::signed_percent(accuracy) << "</b>\n";
}
int parry = at.parry();
if (parry) {
tooltip << _("Parry:") << "<b>"
<< utils::signed_percent(parry) << "</b>\n";
}
add_text(res, flush(str), flush(tooltip));
}
at.set_specials_context_for_listing();
std::vector<bool> active;
const std::vector<std::pair<t_string, t_string> > &specials = at.special_tooltips(&active);
const size_t specials_size = specials.size();
for ( size_t i = 0; i != specials_size; ++i )
{
// Aliases for readability:
const t_string &name = specials[i].first;
const t_string &description = specials[i].second;
const SDL_Color &details_color = active[i] ? font::weapon_details_color :
font::inactive_details_color;
str << span_color(details_color) << " " << " " << name << naps << '\n';
std::string help_page = "weaponspecial_" + name.base_str();
tooltip << _("Weapon special: ") << "<b>" << name << "</b>";
if ( !active[i] )
tooltip << "<i>" << _(" (inactive)") << "</i>";
tooltip << '\n' << description;
add_text(res, flush(str), flush(tooltip), help_page);
}
return damage;
}