/** * Returns whether or not *this matches the given @a filter, ignoring the * complexities introduced by [and], [or], and [not]. */ static bool matches_simple_filter(const attack_type & attack, const config & filter) { const std::vector<std::string>& filter_range = utils::split(filter["range"]); const std::string& filter_damage = filter["damage"]; const std::vector<std::string> filter_name = utils::split(filter["name"]); const std::vector<std::string> filter_type = utils::split(filter["type"]); const std::string filter_special = filter["special"]; if ( !filter_range.empty() && std::find(filter_range.begin(), filter_range.end(), attack.range()) == filter_range.end() ) return false; if ( !filter_damage.empty() && !in_ranges(attack.damage(), utils::parse_ranges(filter_damage)) ) return false; if ( !filter_name.empty() && std::find(filter_name.begin(), filter_name.end(), attack.id()) == filter_name.end() ) return false; if ( !filter_type.empty() && std::find(filter_type.begin(), filter_type.end(), attack.type()) == filter_type.end() ) return false; if ( !filter_special.empty() && !attack.get_special_bool(filter_special, true) ) return false; // Passed all tests. return true; }
/** * Returns whether or not *this matches the given @a filter, ignoring the * complexities introduced by [and], [or], and [not]. */ static bool matches_simple_filter(const attack_type & attack, const config & filter) { const std::vector<std::string>& filter_range = utils::split(filter["range"]); const std::string& filter_damage = filter["damage"]; const std::string& filter_attacks = filter["number"]; const std::string& filter_accuracy = filter["accuracy"]; const std::string& filter_parry = filter["parry"]; const std::string& filter_movement = filter["movement_used"]; const std::vector<std::string> filter_name = utils::split(filter["name"]); const std::vector<std::string> filter_type = utils::split(filter["type"]); const std::string filter_special = filter["special"]; const std::string filter_formula = filter["formula"]; if ( !filter_range.empty() && std::find(filter_range.begin(), filter_range.end(), attack.range()) == filter_range.end() ) return false; if ( !filter_damage.empty() && !in_ranges(attack.damage(), utils::parse_ranges(filter_damage)) ) return false; if (!filter_attacks.empty() && !in_ranges(attack.num_attacks(), utils::parse_ranges(filter_attacks))) return false; if (!filter_accuracy.empty() && !in_ranges(attack.accuracy(), utils::parse_ranges(filter_accuracy))) return false; if (!filter_parry.empty() && !in_ranges(attack.parry(), utils::parse_ranges(filter_parry))) return false; if (!filter_movement.empty() && !in_ranges(attack.movement_used(), utils::parse_ranges(filter_movement))) return false; if ( !filter_name.empty() && std::find(filter_name.begin(), filter_name.end(), attack.id()) == filter_name.end() ) return false; if ( !filter_type.empty() && std::find(filter_type.begin(), filter_type.end(), attack.type()) == filter_type.end() ) return false; if ( !filter_special.empty() && !attack.get_special_bool(filter_special, true) ) return false; if (!filter_formula.empty()) { try { const attack_type_callable callable(attack); const game_logic::formula form(filter_formula); if(!form.evaluate(callable).as_bool()) { return false; } } catch(game_logic::formula_error& e) { lg::wml_error() << "Formula error in weapon filter: " << e.type << " at " << e.filename << ':' << e.line << ")\n"; // Formulae with syntax errors match nothing return false; } } // Passed all tests. return true; }
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; }