improve vmenu sorting

Author: mqrause

src/enums.h

@@ -74,17 +74,20 @@ struct enum_traits<bionic_ui_sort_mode> {
     static constexpr bionic_ui_sort_mode last = bionic_ui_sort_mode::nsort;
 };
 
-enum class list_item_sort_mode : int {
-    DISTANCE,
-    NAME,
-    CATEGORY_DISTANCE,
-    CATEGORY_NAME,
+// default is sorting by distance
+enum class surroundings_menu_sort_flags : int {
+    DEFAULT       = 0,
+    NAME          = 1 << 0,
+    CATEGORY      = 1 << 1,
+    CATEGORY_NAME = NAME | CATEGORY, // this is currently needed to cycle through the option
     count
 };
 
 template<>
-struct enum_traits<list_item_sort_mode> {
-    static constexpr list_item_sort_mode last = list_item_sort_mode::count;
+struct enum_traits<surroundings_menu_sort_flags> {
+    static constexpr surroundings_menu_sort_flags first = surroundings_menu_sort_flags::DEFAULT;
+    static constexpr surroundings_menu_sort_flags last = surroundings_menu_sort_flags::count;
+    static constexpr bool is_flag_enum = true;
 };
 
 // When bool is not enough. NONE, SOME or ALL

src/game.cpp

@@ -6413,23 +6413,6 @@ bool game::take_screenshot() const
 }
 #endif
 
-template<>
-std::string io::enum_to_string<list_item_sort_mode>( list_item_sort_mode data )
-{
-    switch( data ) {
-        case list_item_sort_mode::count:
-        case list_item_sort_mode::DISTANCE:
-            return "DISTANCE";
-        case list_item_sort_mode::NAME:
-            return "NAME";
-        case list_item_sort_mode::CATEGORY_DISTANCE:
-            return "CATEGORY_DISTANCE";
-        case list_item_sort_mode::CATEGORY_NAME:
-            return "CATEGORY_NAME";
-    }
-    cata_fatal( "Invalid list item sort mode" );
-}
-
 void game::list_surroundings()
 {
     temp_exit_fullscreen();

src/inventory_ui.cpp

@@ -383,7 +383,9 @@ void uistatedata::serialize( JsonOut &json ) const
     json.member( "overmap_show_revealed_omts", overmap_show_revealed_omts );
     json.member( "overmap_show_forest_trails", overmap_show_forest_trails );
     json.member( "vmenu_tab", vmenu_tab );
-    json.member( "list_item_sort", list_item_sort );
+    json.member( "vmenu_item_sort", vmenu_item_sort );
+    json.member( "vmenu_monster_sort", vmenu_monster_sort );
+    json.member( "vmenu_terfurn_sort", vmenu_terfurn_sort );
     json.member( "read_items", read_items );
     json.member( "list_item_filter_active", list_item_filter_active );
     json.member( "list_item_downvote_active", list_item_downvote_active );
@@ -507,7 +509,9 @@ void uistatedata::deserialize( const JsonObject &jo )
     jo.read( "distraction_withdrawal", distraction_withdrawal );
     jo.read( "numpad_navigation", numpad_navigation );
     jo.read( "vmenu_tab", vmenu_tab );
-    jo.read( "list_item_sort", list_item_sort );
+    jo.read( "vmenu_item_sort", vmenu_item_sort );
+    jo.read( "vmenu_monster_sort", vmenu_monster_sort );
+    jo.read( "vmenu_terfurn_sort", vmenu_terfurn_sort );
     jo.read( "read_items", read_items );
     jo.read( "list_item_filter_active", list_item_filter_active );
     jo.read( "list_item_downvote_active", list_item_downvote_active );

src/map_entity_stack.cpp

@@ -5,12 +5,17 @@
 #include "character.h"
 #include "color.h"
 #include "creature.h"
+#include "enums.h"
+#include "enum_traits.h"
 #include "item.h"
 #include "item_category.h"
 #include "item_search.h"
+#include "item_tname.h"
 #include "line.h"
+#include "localized_comparator.h"
 #include "mapdata.h"
 #include "monster.h"
+#include "output.h"
 #include "string_formatter.h"
 #include "translation.h"
 #include "translations.h"
@@ -238,18 +243,29 @@ std::string map_entity_stack<map_data_common_t>::get_category() const
 }
 
 template<typename T>
-bool map_entity_stack<T>::compare( const map_entity_stack<T> &, bool ) const
+bool map_entity_stack<T>::compare( const map_entity_stack<T> &, surroundings_menu_sort_flags ) const
 {
     return false;
 }
 
 template<>
-bool map_entity_stack<item>::compare( const map_entity_stack<item> &rhs, bool use_category ) const
+bool map_entity_stack<item>::compare( const map_entity_stack<item> &rhs,
+                                      surroundings_menu_sort_flags sort_flags ) const
 {
-    bool compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
-                        rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    bool compare_dist;
+    if( sort_flags & surroundings_menu_sort_flags::NAME ) {
+        const item *lhs_it = get_selected_entity();
+        const item *rhs_it = rhs.get_selected_entity();
+
+        compare_dist = localized_compare(
+                           to_lower_case( lhs_it->tname( get_selected_count(), tname::unprefixed_tname ) ),
+                           to_lower_case( rhs_it->tname( rhs.get_selected_count(), tname::unprefixed_tname ) ) );
+    } else {
+        compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
+                       rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    }
 
-    if( !use_category ) {
+    if( !( sort_flags & surroundings_menu_sort_flags::CATEGORY ) ) {
         return compare_dist;
     }
 
@@ -263,14 +279,32 @@ bool map_entity_stack<item>::compare( const map_entity_stack<item> &rhs, bool us
     return lhs_cat < rhs_cat;
 }
 
+static std::string mon_name( const map_entity_stack<Creature> &map_stack )
+{
+    std::string mon_name;
+    const Creature *critter = map_stack.get_selected_entity();
+    if( critter->is_monster() ) {
+        return critter->as_monster()->name();
+    } else {
+        return critter->disp_name();
+    }
+}
+
+
 template<>
 bool map_entity_stack<Creature>::compare( const map_entity_stack<Creature> &rhs,
-        bool use_category ) const
+        surroundings_menu_sort_flags sort_flags ) const
 {
-    bool compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
-                        rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    bool compare_dist;
+    if( sort_flags & surroundings_menu_sort_flags::NAME ) {
+        compare_dist = localized_compare( to_lower_case( mon_name( *this ) ),
+                                          to_lower_case( mon_name( rhs ) ) );
+    } else {
+        compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
+                       rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    }
 
-    if( !use_category ) {
+    if( !( sort_flags & surroundings_menu_sort_flags::CATEGORY ) ) {
         return compare_dist;
     }
 
@@ -287,12 +321,20 @@ bool map_entity_stack<Creature>::compare( const map_entity_stack<Creature> &rhs,
 
 template<>
 bool map_entity_stack<map_data_common_t>::compare( const map_entity_stack<map_data_common_t> &rhs,
-        bool use_category ) const
+        surroundings_menu_sort_flags sort_flags ) const
 {
-    bool compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
-                        rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    bool compare_dist;
+    if( sort_flags & surroundings_menu_sort_flags::NAME ) {
+        const map_data_common_t *lhs_it = get_selected_entity();
+        const map_data_common_t *rhs_it = rhs.get_selected_entity();
+        compare_dist = localized_compare( to_lower_case( lhs_it->name() ),
+                                          to_lower_case( rhs_it->name() ) );
+    } else {
+        compare_dist = rl_dist( tripoint_rel_ms(), entities[0].pos ) <
+                       rl_dist( tripoint_rel_ms(), rhs.entities[0].pos );
+    }
 
-    if( !use_category ) {
+    if( !( sort_flags & surroundings_menu_sort_flags::CATEGORY ) ) {
         return compare_dist;
     }
 

src/map_entity_stack.h

@@ -7,6 +7,7 @@
 #include <vector>
 
 #include "coordinates.h"
+#include "enums.h"
 #include "point.h"
 
 template<typename T>
@@ -55,7 +56,8 @@ class map_entity_stack
         // through all older entity groups for a match.
         void add_at_pos( const T *entity, const tripoint_rel_ms &pos, int count = 1 );
 
-        bool compare( const map_entity_stack<T> &rhs, bool use_category = false ) const;
+        bool compare( const map_entity_stack<T> &rhs,
+                      surroundings_menu_sort_flags sort_flags = surroundings_menu_sort_flags::DEFAULT ) const;
         std::string get_category() const;
 };
 

src/surroundings_menu.cpp

@@ -20,6 +20,7 @@
 #include "creature.h"
 #include "debug.h"
 #include "enums.h"
+#include "enum_traits.h"
 #include "game.h"
 #include "game_constants.h"
 #include "game_inventory.h"
@@ -230,6 +231,7 @@ void item_tab_data::init( const Character &you, map &m )
     if( uistate.list_item_downvote_active ) {
         filter_priority_minus = uistate.list_item_downvote;
     }
+    sort_flags = static_cast<surroundings_menu_sort_flags>( uistate.vmenu_item_sort );
     apply_filter();
     if( !filtered_list.empty() ) {
         selected_entry = filtered_list.front();
@@ -306,6 +308,7 @@ void item_tab_data::apply_filter()
     uistate.list_item_filter = filter;
     uistate.list_item_priority = filter_priority_plus;
     uistate.list_item_downvote = filter_priority_minus;
+    uistate.vmenu_item_sort = static_cast<int>( sort_flags );
 
     auto filter_function = item_filter_from_string( uistate.list_item_filter );
 
@@ -318,7 +321,7 @@ void item_tab_data::apply_filter()
     // then apply regular sorting
     std::sort( filtered_list.begin(), filtered_list.end(),
     [&]( const map_entity_stack<item> *lhs, const map_entity_stack<item> *rhs ) {
-        return lhs->compare( *rhs, draw_categories );
+        return lhs->compare( *rhs, sort_flags );
     } );
 
     // then apply priorities
@@ -421,6 +424,7 @@ void monster_tab_data::init( const Character &you )
     if( uistate.list_monster_filter_active ) {
         filter = uistate.monster_filter;
     }
+    sort_flags = static_cast<surroundings_menu_sort_flags>( uistate.vmenu_item_sort );
     apply_filter();
     if( !filtered_list.empty() ) {
         selected_entry = filtered_list.front();
@@ -459,6 +463,7 @@ void monster_tab_data::apply_filter()
 {
     filtered_list.clear();
     uistate.monster_filter = filter;
+    uistate.vmenu_monster_sort = static_cast<int>( sort_flags );
 
     // todo: filter_from_string<Creature>
     // for now just matching creature name
@@ -474,7 +479,7 @@ void monster_tab_data::apply_filter()
     // then apply regular sorting
     std::sort( filtered_list.begin(), filtered_list.end(),
     [&]( const map_entity_stack<Creature> *lhs, const map_entity_stack<Creature> *rhs ) {
-        return lhs->compare( *rhs, draw_categories );
+        return lhs->compare( *rhs, sort_flags );
     } );
 }
 
@@ -573,6 +578,7 @@ void terfurn_tab_data::init( const Character &you, map &m )
     if( uistate.list_terfurn_filter_active ) {
         filter = uistate.terfurn_filter;
     }
+    sort_flags = static_cast<surroundings_menu_sort_flags>( uistate.vmenu_item_sort );
     apply_filter();
     if( !filtered_list.empty() ) {
         selected_entry = filtered_list.front();
@@ -647,6 +653,7 @@ void terfurn_tab_data::apply_filter()
 {
     filtered_list.clear();
     uistate.terfurn_filter = filter;
+    uistate.vmenu_terfurn_sort = static_cast<int>( sort_flags );
 
     // todo: filter_from_string<map_data_common_t>
     // for now just matching creature name
@@ -662,7 +669,7 @@ void terfurn_tab_data::apply_filter()
     std::sort( filtered_list.begin(), filtered_list.end(),
                [&]( const map_entity_stack<map_data_common_t> *lhs,
     const map_entity_stack<map_data_common_t> *rhs ) {
-        return lhs->compare( *rhs, draw_categories );
+        return lhs->compare( *rhs, sort_flags );
     } );
 }
 
@@ -850,7 +857,7 @@ void surroundings_menu::draw_item_tab()
                 for( map_entity_stack<item> *it : item_data.filtered_list ) {
                     bool prio_plus = entry_no <= item_data.priority_plus_end;
                     bool prio_minus = entry_no >= item_data.priority_minus_start;
-                    if( item_data.draw_categories ) {
+                    if( item_data.sort_flags & surroundings_menu_sort_flags::CATEGORY ) {
                         std::string cat = prio_plus ? _( "HIGH PRIORITY" ) : prio_minus ? _( "LOW PRIORITY" ) :
                                           it->get_category();
                         draw_category_separator( cat, last_category, 0 );
@@ -995,7 +1002,7 @@ void surroundings_menu::draw_monster_tab()
             std::string last_category;
             int entry_no = 0;
             for( map_entity_stack<Creature> *it : monster_data.filtered_list ) {
-                if( monster_data.draw_categories ) {
+                if( monster_data.sort_flags & surroundings_menu_sort_flags::CATEGORY ) {
                     draw_category_separator( it->get_category(), last_category, 1 );
                 }
                 bool is_selected = it == monster_data.selected_entry;
@@ -1119,7 +1126,7 @@ void surroundings_menu::draw_terfurn_tab()
             std::string last_category;
             int entry_no = 0;
             for( map_entity_stack<map_data_common_t> *it : terfurn_data.filtered_list ) {
-                if( terfurn_data.draw_categories ) {
+                if( terfurn_data.sort_flags & surroundings_menu_sort_flags::CATEGORY ) {
                     draw_category_separator( it->get_category(), last_category, 0 );
                 }
                 bool is_selected = it == terfurn_data.selected_entry;
@@ -1441,7 +1448,7 @@ void surroundings_menu::change_selected_tab_sorting()
 {
     auto_scroll = true;
     tab_data *data = get_selected_data();
-    data->draw_categories = !data->draw_categories;
+    ++data->sort_flags;
     data->apply_filter();
 }
 

src/surroundings_menu.h

@@ -34,7 +34,7 @@ class tab_data
         input_context ctxt;
         std::string title;
 
-        bool draw_categories = false;
+        surroundings_menu_sort_flags sort_flags = surroundings_menu_sort_flags::DEFAULT;
         // each group will start at a new line
         // currently roughly grouped by actions on an entry and actions on the list as a whole
         std::vector<std::unordered_set<std::string>> hotkey_groups;

src/uistate.h

@@ -216,7 +216,14 @@ class uistatedata
         bool numpad_navigation = false;
 
         // V Menu Stuff
-        list_item_sort_mode list_item_sort = list_item_sort_mode::DISTANCE;
+        // enum serialization relies on string conversion,
+        // which doesn't make too much sense for flag enums
+        // so we store them as ints instead
+        // todo: turn into surroundings_menu_sort_flags
+        // when flag enums can be serialized as numbers
+        int vmenu_item_sort = 0;
+        int vmenu_monster_sort = 0;
+        int vmenu_terfurn_sort = 0;
         std::set<itype_id> read_items;
 
         // These five aren't serialized because deserialize can extract them