faction_select.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2016 - 2025
    Part of the Battle for Wesnoth Project https://www.wesnoth.org/
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY.
 
    See the COPYING file for more details.
*/
 
#define GETTEXT_DOMAIN "wesnoth-lib"
 
#include "gui/dialogs/multiplayer/faction_select.hpp"
 
#include "formatter.hpp"
#include "gettext.hpp"
#include "gui/widgets/button.hpp"
#include "gui/widgets/drawing.hpp"
#include "gui/widgets/label.hpp"
#include "gui/widgets/listbox.hpp"
#include "gui/widgets/menu_button.hpp"
#include "gui/widgets/toggle_button.hpp"
#include "gui/widgets/window.hpp"
#include "help/help.hpp"
#include "preferences/preferences.hpp" // for encountered_units
#include "units/types.hpp"
 
#ifdef __cpp_impl_three_way_comparison
#include <compare>
#endif
#include <functional>
 
namespace gui2::dialogs
{
namespace
{
/** Wrapper type to allow custom sorting for faction names. */
struct faction_sorter
{
    const config* cfg;
};
 
#ifdef __cpp_impl_three_way_comparison
 
/** Must be defined in the same namespace for ADL reasons. */
auto operator<=>(const faction_sorter& lhs, const faction_sorter& rhs)
{
    // Since some eras have multiple random options we can't just
    // assume there is only one random faction on top of the list.
    bool lhs_rand = (*lhs.cfg)["random_faction"].to_bool();
    bool rhs_rand = (*rhs.cfg)["random_faction"].to_bool();
 
    // Group random factions together.
    if(lhs_rand <=> rhs_rand != 0) {
        return std::strong_ordering::greater;
    }
 
    std::string lhs_name = (*lhs.cfg)["name"];
    std::string rhs_name = (*rhs.cfg)["name"];
 
    // TODO C++20: define three-way comparison for t_string?
    auto cmp = translation::compare(lhs_name, rhs_name);
    if(cmp < 0) return std::strong_ordering::less;
    if(cmp > 0) return std::strong_ordering::greater;
 
    return std::strong_ordering::equal;
}
 
#else // TODO: remove block below as soon as humanly possible
 
bool operator<(const faction_sorter& lhs, const faction_sorter& rhs)
{
    bool lhs_rand = (*lhs.cfg)["random_faction"].to_bool();
    bool rhs_rand = (*rhs.cfg)["random_faction"].to_bool();
 
    if(lhs_rand && !rhs_rand) return true;
    if(!lhs_rand && rhs_rand) return false;
 
    return translation::compare((*lhs.cfg)["name"].str(), (*rhs.cfg)["name"].str()) < 0;
}
 
bool operator>(const faction_sorter& lhs, const faction_sorter& rhs)
{
    bool lhs_rand = (*lhs.cfg)["random_faction"].to_bool();
    bool rhs_rand = (*rhs.cfg)["random_faction"].to_bool();
 
    if(lhs_rand && !rhs_rand) return false;
    if(!lhs_rand && rhs_rand) return true;
 
    return translation::compare((*lhs.cfg)["name"].str(), (*rhs.cfg)["name"].str()) > 0;
}
 
#endif
 
} // namespace
 
REGISTER_DIALOG(faction_select)
 
faction_select::faction_select(ng::flg_manager& flg_manager, const std::string& color, const int side)
    : modal_dialog(window_id())
    , flg_manager_(flg_manager)
    , tc_color_(color)
    , side_(side)
    , last_faction_(flg_manager.current_faction_index())
    , last_leader_(flg_manager.current_leader_index())
    , last_gender_(flg_manager.current_gender_index())
{
}
 
void faction_select::pre_show()
{
    find_widget<label>("starting_pos").set_label(std::to_string(side_));
 
    //
    // Set up gender radio buttons
    //
    toggle_button& gender_rand = find_widget<toggle_button>("gender_random");
    toggle_button& gender_male = find_widget<toggle_button>("gender_male");
    toggle_button& gender_female = find_widget<toggle_button>("gender_female");
 
    gender_toggle_.add_member(&gender_rand,   "random");
    gender_toggle_.add_member(&gender_male,   unit_race::s_male);
    gender_toggle_.add_member(&gender_female, unit_race::s_female);
 
    gender_toggle_.set_member_states("random");
 
    gender_toggle_.on_modified(
        std::bind(&faction_select::on_gender_select, this, std::placeholders::_2));
 
    //
    // Set up leader menu button
    //
    connect_signal_notify_modified(find_widget<menu_button>("leader_menu"),
        std::bind(&faction_select::on_leader_select, this));
 
    // Leader's profile button
    find_widget<button>("type_profile").connect_click_handler(
        std::bind(&faction_select::profile_button_callback, this));
 
    //
    // Set up faction list
    //
    listbox& list = find_widget<listbox>("faction_list");
 
    keyboard_capture(&list);
 
    connect_signal_notify_modified(list,
        std::bind(&faction_select::on_faction_select, this));
 
    for(const config *s : flg_manager_.choosable_factions()) {
        const config& side = *s;
 
        // flag_rgb here is unrelated to any handling in the unit class
        const std::string flag_rgb = !side["flag_rgb"].empty() ? side["flag_rgb"].str() : "magenta";
 
        list.add_row(widget_data{
            { "faction_image", {
                { "label", (formatter() << side["image"] << "~RC(" << flag_rgb << ">" << tc_color_ << ")").str() }
            }},
            { "faction_name", {
                { "label", side["name"].str() }
            }},
        });
    }
 
    list.select_row(flg_manager_.current_faction_index());
    list.set_sorters([this](std::size_t i) { return faction_sorter{flg_manager_.choosable_factions()[i]}; });
    list.set_active_sorter("sort_0", flg_manager_.era_info().faction_sort_order, true);
 
    on_faction_select();
}
 
void faction_select::on_faction_select()
{
    const int selected_row = find_widget<listbox>("faction_list").get_selected_row();
 
    if(selected_row == -1) {
        return;
    }
 
    // Since set_current_faction overrides the current leader, save a copy of the previous leader index so the
    // leader dropdown can be set to the appropriate initial selection.
    const int previous_leader_selection = flg_manager_.current_leader_index();
 
    flg_manager_.set_current_faction(selected_row);
 
    std::vector<config> leaders;
 
    for(const std::string& leader : flg_manager_.choosable_leaders()) {
        const unit_type* unit = unit_types.find(leader);
 
        if(unit) {
            const std::string icon = formatter() << unit->image() << "~RC(" << unit->flag_rgb() << ">" << tc_color_ << ")";
            leaders.emplace_back("label", unit->type_name(), "icon", icon);
        } else if(leader == "random") {
            leaders.emplace_back("label", _("Random"), "icon", ng::random_enemy_picture);
        } else if(leader == "null") {
            leaders.emplace_back("label", font::unicode_em_dash);
        } else {
            leaders.emplace_back("label", "?");
        }
    }
 
    menu_button& leader_dropdown = find_widget<menu_button>("leader_menu");
 
    leader_dropdown.set_values(leaders, std::min<int>(leaders.size() - 1, previous_leader_selection));
    leader_dropdown.set_active(leaders.size() > 1 && !flg_manager_.is_saved_game());
 
    on_leader_select();
 
    // Print recruits
    std::vector<t_string> recruit_names;
    for(const auto& recruit : utils::split(flg_manager_.current_faction()["recruit"])) {
        if(const unit_type* rt = unit_types.find(recruit)) {
            recruit_names.push_back(rt->type_name());
        }
    }
 
    std::sort(recruit_names.begin(), recruit_names.end(), [](const std::string& s1, const std::string& s2) {
        return translation::compare(s1, s2) < 0;
    });
 
    find_widget<styled_widget>("recruits").set_label(utils::bullet_list(recruit_names, 0));
}
 
void faction_select::on_leader_select()
{
    flg_manager_.set_current_leader(find_widget<menu_button>("leader_menu").get_value());
 
    // TODO: should we decouple this from the flg manager and instead just check the unit type directly?
    // If that's done so, we'd need to come up with a different check for Random availability.
    gender_toggle_.set_members_enabled([this](const std::string& gender)->bool {
        const std::vector<std::string>& genders = flg_manager_.choosable_genders();
        return std::find(genders.begin(), genders.end(), gender) != genders.end();
    });
 
    update_leader_image();
 
    // Disable the profile button if leader_type is dash or "Random"
    button& profile_button = find_widget<button>("type_profile");
    profile_button.set_active(unit_types.find(flg_manager_.current_leader()) != nullptr);
}
 
void faction_select::profile_button_callback()
{
    if(const unit_type* ut = unit_types.find(flg_manager_.current_leader())) {
        prefs::get().encountered_units().insert(ut->id());
        help::show_unit_description(*ut);
    }
}
 
void faction_select::on_gender_select(const std::string& val)
{
    flg_manager_.set_current_gender(val);
 
    update_leader_image();
}
 
void faction_select::update_leader_image()
{
    std::string leader_image = ng::random_enemy_picture;
 
    if(const unit_type* ut = unit_types.find(flg_manager_.current_leader())) {
        const unit_type& utg = ut->get_gender_unit_type(flg_manager_.current_gender());
        leader_image = formatter() << utg.image() << "~RC(" << utg.flag_rgb() << ">" << tc_color_ << ")";
    }
 
    find_widget<drawing>("leader_image").set_label(leader_image);
}
 
void faction_select::post_show()
{
    //
    // If we're canceling, restore the previous selections. It might be worth looking
    // into only making selections at all here in post_show, but that would require a
    // refactor of the flg_manager class.
    //
    // Also, note it's important to set these in the order of faction -> leader -> gender
    // or the saved indices will be invalid!
    //
    // -- vultraz, 2018-06-16
    //
    if(get_retval() != retval::OK) {
        flg_manager_.set_current_faction(last_faction_);
        flg_manager_.set_current_leader(last_leader_);
        flg_manager_.set_current_gender(last_gender_);
    }
}
 
} // namespace dialogs