cleanup contexts::selected_cubes

Author: salvoilmiosi

src/game/play_verify.cpp

@@ -43,11 +43,9 @@ namespace banggame {
         }
 
         std::unordered_map<card_ptr, int> cubes;
-        for (const auto &entry : ctx.get_all<contexts::selected_cubes>()) {
-            for (card_ptr c : entry.cubes) {
-                if (++cubes[c] > c->num_cubes()) {
-                    return {"ERROR_NOT_ENOUGH_CUBES_ON", c};
-                }
+        for (card_ptr c : contexts::selected_cubes::get_all_cubes(ctx)) {
+            if (++cubes[c] > c->num_cubes()) {
+                return {"ERROR_NOT_ENOUGH_CUBES_ON", c};
             }
         }
 

src/target_types/armedanddangerous/player_per_cube.h

@@ -3,7 +3,7 @@
 
 #include "target_types/base/player.h"
 
-#include "select_cubes.h"
+#include "select_cubes_repeat.h"
 
 namespace banggame {
 
@@ -14,7 +14,7 @@ namespace banggame {
             player_list players;
         };
 
-        targeting_select_cubes target_cubes;
+        targeting_select_cubes_repeat target_cubes;
         targeting_player target_player;
         int extra_players;
 

src/target_types/armedanddangerous/select_cubes.cpp

@@ -33,7 +33,7 @@ namespace banggame {
     }
 
     void targeting_select_cubes::add_context(card_ptr origin_card, player_ptr origin, const effect_holder &effect, effect_context &ctx, const card_list &target_cards) {
-        ctx.add(contexts::selected_cubes{ origin_card, target_cards, ncubes });
+        ctx.add(contexts::selected_cubes{ origin_card, target_cards });
     }
 
     void targeting_select_cubes::on_play(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx, const card_list &target_cards) {

src/target_types/armedanddangerous/select_cubes.h

@@ -39,37 +39,31 @@ namespace banggame {
 
     namespace contexts {        
         struct selected_cubes {
-            const_card_ptr origin_card;
+            card_ptr origin_card;
             card_list cubes;
-            int ncubes;
+
+            selected_cubes(card_ptr origin_card, card_list cubes)
+                : origin_card{origin_card}
+                , cubes{std::move(cubes)} {}
+            
+            selected_cubes(card_ptr origin_card, int ncubes)
+                : origin_card{origin_card}
+                , cubes{static_cast<size_t>(ncubes), origin_card} {}
+
+            static auto get_all_cubes(const effect_context &ctx) {
+                return ctx.get_all<selected_cubes>() | rv::for_each(&selected_cubes::cubes);
+            }
 
             static bool contains(const effect_context &ctx, const_card_ptr origin_card) {
-                for (const selected_cubes &entry : ctx.get_all<selected_cubes>()) {
-                    if (entry.origin_card == origin_card && !entry.cubes.empty()) {
-                        return true;
-                    }
-                }
-                return false;
+                return rn::contains(ctx.get_all<selected_cubes>(), origin_card, &selected_cubes::origin_card);
             }
 
             static int count_repeats(const effect_context &ctx, const_card_ptr origin_card) {
-                int result = 0;
-                for (const selected_cubes &entry : ctx.get_all<selected_cubes>()) {
-                    if (entry.origin_card == origin_card && entry.ncubes != 0) {
-                        result += entry.cubes.size() / entry.ncubes;
-                    }
-                }
-                return result;
+                return static_cast<int>(rn::count(ctx.get_all<selected_cubes>(), origin_card, &selected_cubes::origin_card));
             }
 
             static int count_selected_on(const effect_context &ctx, const_card_ptr target_card) {
-                int result = 0;
-                for (const selected_cubes &entry : ctx.get_all<selected_cubes>()) {
-                    for (card_ptr c : entry.cubes) {
-                        if (c == target_card) ++result;
-                    }
-                }
-                return result;
+                return static_cast<int>(rn::count(get_all_cubes(ctx), target_card));
             }
         };
     }

src/target_types/armedanddangerous/select_cubes_optional.h

@@ -21,6 +21,12 @@ namespace banggame {
             return {};
         }
 
+        void add_context(card_ptr origin_card, player_ptr origin, const effect_holder &effect, effect_context &ctx, const card_list &target) {
+            if (!target.empty()) {
+                targeting_select_cubes::add_context(origin_card, origin, effect, ctx, target);
+            }
+        }
+
         game_string get_error(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx, const card_list &target) {
             if (!target.empty()) {
                 return targeting_select_cubes::get_error(origin_card, origin, effect, ctx, target);

src/target_types/armedanddangerous/select_cubes_repeat.cpp

@@ -10,6 +10,12 @@ namespace banggame {
 
         return sample_elements(get_all_cubes(origin), ncubes * num_repeats, origin->m_game->bot_rng);
     }
+    
+    void targeting_select_cubes_repeat::add_context(card_ptr origin_card, player_ptr origin, const effect_holder &effect, effect_context &ctx, const card_list &target) {
+        for (auto chunk : target | rv::chunk(ncubes)) {
+            ctx.add(contexts::selected_cubes{ origin_card, rn::to<card_list>(chunk) });
+        }
+    }
 
     game_string targeting_select_cubes_repeat::get_error(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx, const card_list &target_cards) {
         if (target_cards.size() % ncubes != 0) {

src/target_types/armedanddangerous/select_cubes_repeat.h

@@ -15,6 +15,7 @@ namespace banggame {
         }
 
         card_list random_target(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx);
+        void add_context(card_ptr origin_card, player_ptr origin, const effect_holder &effect, effect_context &ctx, const card_list &target);
         game_string get_error(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx, const card_list &target);
     };
 

src/target_types/armedanddangerous/self_cubes.cpp

@@ -14,11 +14,7 @@ namespace banggame {
     }
 
     void targeting_self_cubes::add_context(card_ptr origin_card, player_ptr origin, const effect_holder &effect, effect_context &ctx, value_type) {
-        ctx.add(contexts::selected_cubes{
-            origin_card,
-            card_list{static_cast<size_t>(ncubes), origin_card},
-            ncubes
-        });
+        ctx.add(contexts::selected_cubes{ origin_card, ncubes });
     }
 
     void targeting_self_cubes::on_play(card_ptr origin_card, player_ptr origin, const effect_holder &effect, const effect_context &ctx, value_type) {