20460432036

Committed 26 Sep 2025 11:25AM UTC coverage: 70.326% (-0.07%) from 70.399%

Build # 20460432036

Build Type

push

github

Committed by

web-flow

Commit Message

Update bges.txt (#95)

Updated the BGEs with the new values uploaded to the game on 2025-09-25

Run Details

4773 of 6787 relevant lines covered (70.33%)

9371006.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.14

/algorithms_util.cpp

#include "algorithms_util.h"
void copy_deck(Deck* src,Deck* dst)
{
        dst->commander = src->commander;
        dst->alpha_dominion = src->alpha_dominion;
        dst->cards = src->cards;
}
std::string card_id_name(const Card* card)
{
        std::stringstream ios;
        if (card)
        {
                ios << "[" << card->m_id << "] " << card->m_name;
        }
        else
        {
                ios << "-void-";
        }
        return ios.str();
}
std::string card_slot_id_names(const std::vector<std::pair<signed, const Card *>> card_list)
{
        if (card_list.empty())
        {
                return "-void-";
        }
        std::stringstream ios;
        std::string separator = "";
        for (const auto & card_it : card_list)
        {
                ios << separator;
                separator = ", ";
                if (card_it.first >= 0)
                { ios << card_it.first << " "; }
                ios << "[" << card_it.second->m_id << "] " << card_it.second->m_name;
        }
        return ios.str();
}
// remove val from oppo if found, otherwise append val to self
        template <typename C>
void append_unless_remove(C & self, C & oppo, typename C::const_reference val)
{
        for (auto it = oppo.begin(); it != oppo.end(); ++ it)
        {
                if (*it == val)
                {
                        oppo.erase(it);
                        return;
                }
        }
        self.push_back(val);
}

// insert card at to_slot into deck limited by fund; store deck_cost
// return true if affordable
bool adjust_deck(Deck * deck, const signed from_slot, const signed to_slot, const Card * card, unsigned fund, std::mt19937 & re, unsigned & deck_cost,
                std::vector<std::pair<signed, const Card *>> & cards_out, std::vector<std::pair<signed, const Card *>> & cards_in)
{
        bool is_random = (deck->strategy == DeckStrategy::random) || (deck->strategy == DeckStrategy::flexible);
        cards_out.clear();
        cards_in.clear();
        if (from_slot < 0)
        {
                if (card->m_category == CardCategory::dominion_alpha)
                { // change alpha dominion
                        cards_out.emplace_back(-1, deck->alpha_dominion);
                        deck->alpha_dominion = card;
                        cards_in.emplace_back(-1, deck->alpha_dominion);
                        deck_cost = get_deck_cost(deck);
                        return true;
                }

                // change commander
                cards_out.emplace_back(-1, deck->commander);
                deck->commander = card;
                cards_in.emplace_back(-1, deck->commander);
                deck_cost = get_deck_cost(deck);
                return (deck_cost <= fund);
        }
        if (from_slot < (signed)deck->cards.size())
        { // remove card from the deck
                cards_out.emplace_back(is_random ? -1 : from_slot, deck->cards[from_slot]);
                deck->cards.erase(deck->cards.begin() + from_slot);
        }
        if (card == nullptr)
        { // remove card (no new replacement for removed card)
                deck_cost = get_deck_cost(deck);
                return (deck_cost <= fund);
        }

        // backup deck cards
        const Card * old_commander = deck->commander;
        std::vector<const Card *> cards = deck->cards;

        // try to add new card into the deck, downgrade it if necessary
        {
                const Card * candidate_card = card;
                deck->commander = nullptr;
                deck->cards.clear();
                deck->cards.emplace_back(card);
                deck_cost = get_deck_cost(deck);
                if (!use_top_level_card && (deck_cost > fund))
                {
                        while ((deck_cost > fund) && !candidate_card->is_low_level_card())
                        {
                                candidate_card = candidate_card->downgraded();
                                deck->cards[0] = candidate_card;
                                deck_cost = get_deck_cost(deck);
                        }
                }
                if (deck_cost > fund)
                { return false; }
                cards_in.emplace_back(is_random ? -1 : to_slot, deck->cards[0]);
        }

        // try to add commander into the deck, downgrade it if necessary
        {
                const Card * candidate_card = old_commander;
                deck->commander = candidate_card;
                deck_cost = get_deck_cost(deck);
                if (!use_top_level_commander && (deck_cost > fund))
                {
                        while ((deck_cost > fund) && !candidate_card->is_low_level_card())
                        {
                                candidate_card = candidate_card->downgraded();
                                deck->commander = candidate_card;
                                deck_cost = get_deck_cost(deck);
                        }
                }
                if (deck_cost > fund)
                { return false; }
                if (deck->commander != old_commander)
                {
                        append_unless_remove(cards_out, cards_in, {-1, old_commander});
                        append_unless_remove(cards_in, cards_out, {-1, deck->commander});
                }
        }

        // added backuped deck cards back (place cards strictly before/after card inserted above according to slot index)
        for (signed i = 0; i < (signed)cards.size(); ++ i)
        {
                // try to add cards[i] into the deck, downgrade it if necessary
                const Card * candidate_card = cards[i];
                auto in_it = deck->cards.end() - (i < to_slot); // (before/after according to slot index)
                in_it = deck->cards.insert(in_it, candidate_card);
                deck_cost = get_deck_cost(deck);
                if (!use_top_level_card && (deck_cost > fund))
                {
                        while ((deck_cost > fund) && !candidate_card->is_low_level_card())
                        {
                                candidate_card = candidate_card->downgraded();
                                *in_it = candidate_card;
                                deck_cost = get_deck_cost(deck);
                        }
                }
                if (deck_cost > fund)
                { return false; }
                if (*in_it != cards[i])
                {
                        append_unless_remove(cards_out, cards_in, {is_random ? -1 : i + (i >= from_slot), cards[i]});
                        append_unless_remove(cards_in, cards_out, {is_random ? -1 : i + (i >= to_slot), *in_it});
                }
        }
        return !cards_in.empty() || !cards_out.empty();
}

unsigned check_requirement(const Deck* deck, const Requirement & requirement
#ifndef NQUEST
                , const Quest & quest
#endif
                )
{
        unsigned gap = safe_minus(min_deck_len, deck->cards.size());
        if (!requirement.num_cards.empty())
        {
                std::unordered_map<const Card*, unsigned> num_cards;
                num_cards[deck->commander] = 1;
                for (auto card: deck->cards)
                {
                        ++ num_cards[card];
                }
                for (auto it: requirement.num_cards)
                {
                        gap += safe_minus(it.second, num_cards[it.first]);
                }
        }
#ifndef NQUEST
        if (quest.quest_type != QuestType::none)
        {
                unsigned potential_value = 0;
                switch (quest.quest_type)
                {
                        case QuestType::skill_use:
                        case QuestType::skill_damage:
                                for (const auto & ss: deck->commander->m_skills)
                                {
                                        if (quest.quest_key == ss.id)
                                        {
                                                potential_value = quest.quest_value;
                                                break;
                                        }
                                }
                                break;
                        case QuestType::faction_assault_card_kill:
                        case QuestType::type_card_kill:
                                potential_value = quest.quest_value;
                                break;
                        default:
                                break;
                }
                for (auto card: deck->cards)
                {
                        switch (quest.quest_type)
                        {
                                case QuestType::skill_use:
                                case QuestType::skill_damage:
                                        for (const auto & ss: card->m_skills)
                                        {
                                                if (quest.quest_key == ss.id)
                                                {
                                                        potential_value = quest.quest_value;
                                                        break;
                                                }
                                        }
                                        break;
                                case QuestType::faction_assault_card_use:
                                        potential_value += (quest.quest_key == card->m_faction);
                                        break;
                                case QuestType::type_card_use:
                                        potential_value += (quest.quest_key == card->m_type);
                                        break;
                                default:
                                        break;
                        }
                        if (potential_value >= (quest.must_fulfill ? quest.quest_value : 1))
                        {
                                break;
                        }
                }
                gap += safe_minus(quest.must_fulfill ? quest.quest_value : 1, potential_value);
        }
#endif
        return gap;
}

1	#include "algorithms_util.h"
2	void copy_deck(Deck* src,Deck* dst)	3,078✔
3	{
4	dst->commander = src->commander;	3,078✔
5	dst->alpha_dominion = src->alpha_dominion;	3,078✔
6	dst->cards = src->cards;	3,078✔
7	}	3,078✔
8	std::string card_id_name(const Card* card)	×
9	{
10	std::stringstream ios;	×
11	if (card)	×
12	{
13	ios << "[" << card->m_id << "] " << card->m_name;	×
14	}
15	else
16	{
17	ios << "-void-";	×
18	}
19	return ios.str();	×
20	}	×
21	std::string card_slot_id_names(const std::vector<std::pair<signed, const Card *>> card_list)	46✔
22	{
23	if (card_list.empty())	46✔
24	{
25	return "-void-";	×
26	}
27	std::stringstream ios;	46✔
28	std::string separator = "";	46✔
29	for (const auto & card_it : card_list)	92✔
30	{
31	ios << separator;	46✔
32	separator = ", ";	46✔
33	if (card_it.first >= 0)	46✔
34	{ ios << card_it.first << " "; }	×
35	ios << "[" << card_it.second->m_id << "] " << card_it.second->m_name;	46✔
36	}
37	return ios.str();	46✔
38	}	46✔
39	// remove val from oppo if found, otherwise append val to self
40	template <typename C>
41	void append_unless_remove(C & self, C & oppo, typename C::const_reference val)	×
42	{
43	for (auto it = oppo.begin(); it != oppo.end(); ++ it)	×
44	{
45	if (*it == val)	×
46	{
47	oppo.erase(it);	×
48	return;	×
49	}
50	}
51	self.push_back(val);	×
52	}
53
54	// insert card at to_slot into deck limited by fund; store deck_cost
55	// return true if affordable
56	bool adjust_deck(Deck * deck, const signed from_slot, const signed to_slot, const Card * card, unsigned fund, std::mt19937 & re, unsigned & deck_cost,	4,567✔
57	std::vector<std::pair<signed, const Card >> & cards_out, std::vector<std::pair<signed, const Card >> & cards_in)
58	{
59	bool is_random = (deck->strategy == DeckStrategy::random) \|\| (deck->strategy == DeckStrategy::flexible);	4,567✔
60	cards_out.clear();	4,567✔
61	cards_in.clear();	4,567✔
62	if (from_slot < 0)	4,567✔
63	{
64	if (card->m_category == CardCategory::dominion_alpha)	1,494✔
65	{ // change alpha dominion
66	cards_out.emplace_back(-1, deck->alpha_dominion);	335✔
67	deck->alpha_dominion = card;	335✔
68	cards_in.emplace_back(-1, deck->alpha_dominion);	335✔
69	deck_cost = get_deck_cost(deck);	335✔
70	return true;	335✔
71	}
72
73	// change commander
74	cards_out.emplace_back(-1, deck->commander);	1,159✔
75	deck->commander = card;	1,159✔
76	cards_in.emplace_back(-1, deck->commander);	1,159✔
77	deck_cost = get_deck_cost(deck);	1,159✔
78	return (deck_cost <= fund);	1,159✔
79	}
80	if (from_slot < (signed)deck->cards.size())	3,073✔
81	{ // remove card from the deck
82	cards_out.emplace_back(is_random ? -1 : from_slot, deck->cards[from_slot]);	2,969✔
83	deck->cards.erase(deck->cards.begin() + from_slot);	2,969✔
84	}
85	if (card == nullptr)	3,073✔
86	{ // remove card (no new replacement for removed card)
87	deck_cost = get_deck_cost(deck);	117✔
88	return (deck_cost <= fund);	117✔
89	}
90
91	// backup deck cards
92	const Card * old_commander = deck->commander;	2,956✔
93	std::vector<const Card *> cards = deck->cards;	2,956✔
94
95	// try to add new card into the deck, downgrade it if necessary
96	{	2,956✔
97	const Card * candidate_card = card;	2,956✔
98	deck->commander = nullptr;	2,956✔
99	deck->cards.clear();	2,956✔
100	deck->cards.emplace_back(card);	2,956✔
101	deck_cost = get_deck_cost(deck);	2,956✔
102	if (!use_top_level_card && (deck_cost > fund))	2,956✔
103	{
104	while ((deck_cost > fund) && !candidate_card->is_low_level_card())	×
105	{
106	candidate_card = candidate_card->downgraded();	×
107	deck->cards[0] = candidate_card;	×
108	deck_cost = get_deck_cost(deck);	×
109	}
110	}
111	if (deck_cost > fund)	2,956✔
112	{ return false; }
113	cards_in.emplace_back(is_random ? -1 : to_slot, deck->cards[0]);	2,956✔
114	}
115
116	// try to add commander into the deck, downgrade it if necessary
117	{	2,956✔
118	const Card * candidate_card = old_commander;	2,956✔
119	deck->commander = candidate_card;	2,956✔
120	deck_cost = get_deck_cost(deck);	2,956✔
121	if (!use_top_level_commander && (deck_cost > fund))	2,956✔
122	{
123	while ((deck_cost > fund) && !candidate_card->is_low_level_card())	×
124	{
125	candidate_card = candidate_card->downgraded();	×
126	deck->commander = candidate_card;	×
127	deck_cost = get_deck_cost(deck);	×
128	}
129	}
130	if (deck_cost > fund)	2,956✔
131	{ return false; }
132	if (deck->commander != old_commander)	2,956✔
133	{
134	append_unless_remove(cards_out, cards_in, {-1, old_commander});	×
135	append_unless_remove(cards_in, cards_out, {-1, deck->commander});	×
136	}
137	}
138
139	// added backuped deck cards back (place cards strictly before/after card inserted above according to slot index)
140	for (signed i = 0; i < (signed)cards.size(); ++ i)	22,936✔
141	{
142	// try to add cards[i] into the deck, downgrade it if necessary
143	const Card * candidate_card = cards[i];	21,132✔
144	auto in_it = deck->cards.end() - (i < to_slot); // (before/after according to slot index)	21,132✔
145	in_it = deck->cards.insert(in_it, candidate_card);	21,132✔
146	deck_cost = get_deck_cost(deck);	21,132✔
147	if (!use_top_level_card && (deck_cost > fund))	21,132✔
148	{
149	while ((deck_cost > fund) && !candidate_card->is_low_level_card())	×
150	{
151	candidate_card = candidate_card->downgraded();	×
152	*in_it = candidate_card;	×
153	deck_cost = get_deck_cost(deck);	×
154	}
155	}
156	if (deck_cost > fund)	21,132✔
157	{ return false; }	1,152✔
158	if (*in_it != cards[i])	19,980✔
159	{
160	append_unless_remove(cards_out, cards_in, {is_random ? -1 : i + (i >= from_slot), cards[i]});	×
161	append_unless_remove(cards_in, cards_out, {is_random ? -1 : i + (i >= to_slot), *in_it});	×
162	}
163	}
164	return !cards_in.empty() \|\| !cards_out.empty();	1,804✔
165	}	2,956✔
166
167	unsigned check_requirement(const Deck* deck, const Requirement & requirement	3,475✔
168	#ifndef NQUEST
169	, const Quest & quest
170	#endif
171	)
172	{
173	unsigned gap = safe_minus(min_deck_len, deck->cards.size());	3,475✔
174	if (!requirement.num_cards.empty())	3,475✔
175	{
176	std::unordered_map<const Card*, unsigned> num_cards;	×
177	num_cards[deck->commander] = 1;	×
178	for (auto card: deck->cards)	×
179	{
180	++ num_cards[card];	×
181	}
182	for (auto it: requirement.num_cards)	×
183	{
184	gap += safe_minus(it.second, num_cards[it.first]);	×
185	}
186	}	×
187	#ifndef NQUEST
188	if (quest.quest_type != QuestType::none)
189	{
190	unsigned potential_value = 0;
191	switch (quest.quest_type)
192	{
193	case QuestType::skill_use:
194	case QuestType::skill_damage:
195	for (const auto & ss: deck->commander->m_skills)
196	{
197	if (quest.quest_key == ss.id)
198	{
199	potential_value = quest.quest_value;
200	break;
201	}
202	}
203	break;
204	case QuestType::faction_assault_card_kill:
205	case QuestType::type_card_kill:
206	potential_value = quest.quest_value;
207	break;
208	default:
209	break;
210	}
211	for (auto card: deck->cards)
212	{
213	switch (quest.quest_type)
214	{
215	case QuestType::skill_use:
216	case QuestType::skill_damage:
217	for (const auto & ss: card->m_skills)
218	{
219	if (quest.quest_key == ss.id)
220	{
221	potential_value = quest.quest_value;
222	break;
223	}
224	}
225	break;
226	case QuestType::faction_assault_card_use:
227	potential_value += (quest.quest_key == card->m_faction);
228	break;
229	case QuestType::type_card_use:
230	potential_value += (quest.quest_key == card->m_type);
231	break;
232	default:
233	break;
234	}
235	if (potential_value >= (quest.must_fulfill ? quest.quest_value : 1))
236	{
237	break;
238	}
239	}
240	gap += safe_minus(quest.must_fulfill ? quest.quest_value : 1, potential_value);
241	}
242	#endif
243	return gap;	3,475✔
244	}

APN-Pucky / tyrant_optimize / 20460432036

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous