Adds Genesys support for Deckbuilding and Room Creation

gframe/data_manager.cpp

@@ -9,6 +9,9 @@
 #include "common.h"
 #include "file_stream.h"
 #include "fmt.h"
+#include "game.h"
+#include "deck_manager.h"
+#include "deck_con.h"
 
 #if !defined(SQLITE_NOTICE)
 #define SQLITE_NOTICE      27
@@ -660,5 +663,22 @@ bool DataManager::deck_sort_name(const CardDataC* p1, const CardDataC* p2) {
 		return res < 0;
 	return check_codes(p1, p2);
 }
+bool DataManager::deck_sort_genesys(const CardDataC* p1, const CardDataC* p2) {
+	if (check_either_skills(p1->type, p2->type))
+		return check_skills(p1, p2);
+	int32_t p1_points = 0;
+	int32_t p2_points = 0;
+	if (mainGame->deckBuilder.filterList) {
+		auto it1 = mainGame->deckBuilder.filterList->GetLimitationIterator(p1);
+		if (it1 != mainGame->deckBuilder.filterList->content.end())
+			p1_points = it1->second;
+		auto it2 = mainGame->deckBuilder.filterList->GetLimitationIterator(p2);
+		if (it2 != mainGame->deckBuilder.filterList->content.end())
+			p2_points = it2->second;
+	}
+	if (p1_points != p2_points)
+		return p1_points < p2_points;
+	return deck_sort_lv(p1, p2);
+}
 
 }

gframe/data_manager.h

@@ -184,6 +184,7 @@ class DataManager {
 	static bool deck_sort_atk(const CardDataC* l1, const CardDataC* l2);
 	static bool deck_sort_def(const CardDataC* l1, const CardDataC* l2);
 	static bool deck_sort_name(const CardDataC* l1, const CardDataC* l2);
+	static bool deck_sort_genesys(const CardDataC* l1, const CardDataC* l2);
 private:
 	std::unique_ptr<sqlite3_vfs> irrvfs;
 	template<typename T1, typename T2 = T1>

gframe/deck_con.cpp

@@ -88,6 +88,7 @@ void DeckBuilder::Initialize(bool refresh) {
 	is_draging = false;
 	prev_deck = mainGame->cbDBDecks->getSelected();
 	prev_operation = 0;
+	RefreshLimitationStatus();
 	mainGame->SetMessageWindow();
 	mainGame->device->setEventReceiver(this);
 }
@@ -439,7 +440,18 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 				break;
 			}
 			case BUTTON_MARKS_FILTER: {
-				mainGame->PopupElement(mainGame->wLinkMarks);
+				if (filterList && filterList->genesys)
+					mainGame->PopupElement(mainGame->wGenesys);
+				else
+					mainGame->PopupElement(mainGame->wLinkMarks);
+				break;
+			}
+			case BUTTON_GENESYS_OK: {
+				filter_genesys_op = mainGame->cbGenesysOp->getSelected();
+				filter_genesys_val1 = _wtoi(mainGame->ebGenesys1->getText());
+				filter_genesys_val2 = _wtoi(mainGame->ebGenesys2->getText());
+				mainGame->HideElement(mainGame->wGenesys);
+				StartFilter(true);
 				break;
 			}
 			case BUTTON_MARKERS_OK: {
@@ -511,9 +523,19 @@ bool DeckBuilder::OnEvent(const irr::SEvent& event) {
 			case COMBOBOX_DBLFLIST: {
 				filterList = &gdeckManager->_lfList[mainGame->cbDBLFList->getSelected()];
 				mainGame->ReloadCBLimit();
+				RefreshLimitationStatus();
 				StartFilter(true);
 				break;
 			}
+			case COMBOBOX_GENESYS_OP: {
+				if (mainGame->cbGenesysOp->getSelected() == 3) { // Between
+					mainGame->ebGenesys2->setVisible(true);
+				} else {
+					mainGame->ebGenesys2->setVisible(false);
+					mainGame->ebGenesys2->setText(L"");
+				}
+				break;
+			}
 			case COMBOBOX_DBDECKS: {
 				int sel = mainGame->cbDBDecks->getSelected();
 				if(sel >= 0)
@@ -1033,6 +1055,9 @@ bool DeckBuilder::FiltersChanged() {
 	CHECK_AND_SET(filter_scl);
 	CHECK_AND_SET(filter_marks);
 	CHECK_AND_SET(filter_lm);
+	CHECK_AND_SET(filter_genesys_op);
+	CHECK_AND_SET(filter_genesys_val1);
+	CHECK_AND_SET(filter_genesys_val2);
 	return res;
 }
 #undef CHECK_AND_SET
@@ -1170,7 +1195,9 @@ void DeckBuilder::FilterCards(bool force_refresh) {
 	mainGame->scrFilter->setPos(0);
 }
 bool DeckBuilder::CheckCardProperties(const CardDataM& data) {
-	if(data._data.type & TYPE_TOKEN || data._data.ot & SCOPE_HIDDEN || ((data._data.ot & SCOPE_OFFICIAL) != data._data.ot && (!mainGame->chkAnime->isChecked() && !filterList->whitelist)))
+	if(data._data.type & TYPE_TOKEN || data._data.ot & SCOPE_HIDDEN || ((data._data.ot & SCOPE_OFFICIAL) != data._data.ot && (!mainGame->chkAnime->isChecked() && !filterList->whitelist && !filterList->genesys)))
+		return false;
+	if (filterList->genesys && (!(data._data.ot & SCOPE_TCG) || (data._data.type & (TYPE_PENDULUM | TYPE_LINK))))
 		return false;
 	switch(filter_type) {
 	case 1: {
@@ -1232,25 +1259,65 @@ bool DeckBuilder::CheckCardProperties(const CardDataM& data) {
 		return false;
 	if(filter_marks && (data._data.link_marker & filter_marks) != filter_marks)
 		return false;
-	if((filter_lm != LIMITATION_FILTER_NONE || filterList->whitelist) && filter_lm != LIMITATION_FILTER_ALL) {
+	if (filterList->genesys && filter_genesys_op != 0xFFFFFFFF) {
+		auto it = filterList->GetLimitationIterator(&data._data);
+		int points = (it == filterList->content.end()) ? 0 : it->second;
+		switch (filter_genesys_op) {
+		case 0: // >=
+			if (points < filter_genesys_val1) return false;
+			break;
+		case 1: // <=
+			if (points > filter_genesys_val1) return false;
+			break;
+		case 2: // ==
+			if (points != filter_genesys_val1) return false;
+			break;
+		case 3: // Between
+			if (points < filter_genesys_val1 || points > filter_genesys_val2) return false;
+			break;
+		}
+	}
+	if((filter_lm != LIMITATION_FILTER_NONE || filterList->whitelist || filterList->genesys) && filter_lm != LIMITATION_FILTER_ALL) {
 		auto flit = filterList->GetLimitationIterator(&data._data);
 		int count = 3;
 		if(flit == filterList->content.end()) {
 			if(filterList->whitelist)
 				count = -1;
 		} else
 			count = flit->second;
-		switch(filter_lm) {
-			case LIMITATION_FILTER_BANNED:
-			case LIMITATION_FILTER_LIMITED:
-			case LIMITATION_FILTER_SEMI_LIMITED:
-				if(count != filter_lm - 1)
-					return false;
-				break;
-			case LIMITATION_FILTER_UNLIMITED:
-				if(count < 3)
-					return false;
-				break;
+		if (filterList->genesys) {
+			switch (filter_lm) {
+				case LIMITATION_FILTER_UNLIMITED:
+					if (count < 3 && flit != filterList->content.end())
+						return false;
+					break;
+				case LIMITATION_FILTER_BANNED:
+					if (count != 1)
+						return false;
+					break;
+				case LIMITATION_FILTER_LIMITED:
+					if (count != 2)
+						return false;
+					break;
+				case LIMITATION_FILTER_SEMI_LIMITED:
+					if (count != 3)
+						return false;
+					break;
+				default:
+					break;
+			}
+		} else {
+			switch (filter_lm) {
+				case LIMITATION_FILTER_BANNED:
+				case LIMITATION_FILTER_LIMITED:
+				case LIMITATION_FILTER_SEMI_LIMITED:
+					if (count != filter_lm - 1)
+						return false;
+					break;
+				case LIMITATION_FILTER_UNLIMITED:
+					if (count < 3)
+						return false;
+					break;
 			case LIMITATION_FILTER_OCG:
 				if(data._data.ot != SCOPE_OCG)
 					return false;
@@ -1297,6 +1364,7 @@ bool DeckBuilder::CheckCardProperties(const CardDataM& data) {
 				break;
 			default:
 				break;
+			}
 		}
 		if(filterList->whitelist && count < 0)
 			return false;
@@ -1372,6 +1440,13 @@ void DeckBuilder::ClearFilter() {
 	filter_marks = 0;
 	for(int i = 0; i < 8; i++)
 		mainGame->btnMark[i]->setPressed(false);
+	filter_genesys_op = 0xFFFFFFFF;
+	filter_genesys_val1 = 0;
+	filter_genesys_val2 = 0;
+	mainGame->cbGenesysOp->setSelected(0);
+	mainGame->ebGenesys1->setText(L"");
+	mainGame->ebGenesys2->setText(L"");
+	mainGame->ebGenesys2->setVisible(false);
 }
 void DeckBuilder::SortList() {
 	auto last = [&] {
@@ -1401,6 +1476,9 @@ void DeckBuilder::SortList() {
 	case 3:
 		sort(DataManager::deck_sort_name);
 		break;
+	case 4:
+		sort(DataManager::deck_sort_genesys);
+		break;
 	}
 }
 void DeckBuilder::ClearDeck() {
@@ -1425,6 +1503,7 @@ void DeckBuilder::ClearDeck() {
 	side_monster_count = 0;
 	side_spell_count = 0;
 	side_trap_count = 0;
+	genesys_points = 0;
 }
 void DeckBuilder::RefreshLimitationStatus() {
 	main_and_extra_legend_count_monster = DeckManager::CountLegends(current_deck.main, TYPE_MONSTER) + DeckManager::CountLegends(current_deck.extra, TYPE_MONSTER);
@@ -1444,6 +1523,28 @@ void DeckBuilder::RefreshLimitationStatus() {
 	side_monster_count = DeckManager::TypeCount(current_deck.side, TYPE_MONSTER);
 	side_spell_count = DeckManager::TypeCount(current_deck.side, TYPE_SPELL);
 	side_trap_count = DeckManager::TypeCount(current_deck.side, TYPE_TRAP);
+	genesys_points = 0;
+	if (filterList->genesys) {
+		for (auto* card : current_deck.main) {
+			auto it = filterList->GetLimitationIterator(card);
+			if (it != filterList->content.end())
+				genesys_points += it->second;
+		}
+		for (auto* card : current_deck.extra) {
+			auto it = filterList->GetLimitationIterator(card);
+			if (it != filterList->content.end())
+				genesys_points += it->second;
+		}
+		for (auto* card : current_deck.side) {
+			auto it = filterList->GetLimitationIterator(card);
+			if (it != filterList->content.end())
+				genesys_points += it->second;
+		}
+	}
+	if (filterList->genesys)
+		mainGame->btnMarksFilter->setText(gDataManager->GetSysString(12504).data());
+	else
+		mainGame->btnMarksFilter->setText(gDataManager->GetSysString(1374).data());
 }
 void DeckBuilder::RefreshLimitationStatusOnRemoved(const CardDataC* card, DeckType location) {
 	switch(location) {
@@ -1466,6 +1567,11 @@ void DeckBuilder::RefreshLimitationStatusOnRemoved(const CardDataC* card, DeckTy
 			}
 			if(card->type & TYPE_SKILL)
 				--main_skill_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points -= it->second;
+			}
 			break;
 		}
 		case DeckType::EXTRA:
@@ -1482,6 +1588,11 @@ void DeckBuilder::RefreshLimitationStatusOnRemoved(const CardDataC* card, DeckTy
 				--extra_link_count;
 			if(card->type & TYPE_RITUAL)
 				--extra_rush_ritual_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points -= it->second;
+			}
 			break;
 		}
 		case DeckType::SIDE:
@@ -1492,6 +1603,11 @@ void DeckBuilder::RefreshLimitationStatusOnRemoved(const CardDataC* card, DeckTy
 				--side_spell_count;
 			if(card->type & TYPE_TRAP)
 				--side_trap_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points -= it->second;
+			}
 			break;
 		}
 	}
@@ -1517,6 +1633,11 @@ void DeckBuilder::RefreshLimitationStatusOnAdded(const CardDataC* card, DeckType
 			}
 			if(card->type & TYPE_SKILL)
 				++main_skill_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points += it->second;
+			}
 			break;
 		}
 		case DeckType::EXTRA:
@@ -1533,6 +1654,11 @@ void DeckBuilder::RefreshLimitationStatusOnAdded(const CardDataC* card, DeckType
 				++extra_link_count;
 			if(card->type & TYPE_RITUAL)
 				++extra_rush_ritual_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points += it->second;
+			}
 			break;
 		}
 		case DeckType::SIDE:
@@ -1543,6 +1669,11 @@ void DeckBuilder::RefreshLimitationStatusOnAdded(const CardDataC* card, DeckType
 				++side_spell_count;
 			if(card->type & TYPE_TRAP)
 				++side_trap_count;
+			if (filterList->genesys) {
+				auto it = filterList->GetLimitationIterator(card);
+				if (it != filterList->content.end())
+					genesys_points += it->second;
+			}
 			break;
 		}
 	}
@@ -1647,20 +1778,24 @@ bool DeckBuilder::check_limit(const CardDataC* pointer) {
 	uint32_t limitcode = pointer->alias ? pointer->alias : pointer->code;
 	int found = 0;
 	int limit = filterList->whitelist ? 0 : 3;
+	if (filterList->genesys)
+		limit = 3;
 	auto endit = filterList->content.end();
 	auto it = filterList->GetLimitationIterator(pointer);
-	if(it != endit)
+	if(it != endit && !filterList->genesys)
 		limit = it->second;
 	if(limit == 0)
 		return false;
 	const auto& deck = current_deck;
 	for(auto* plist : { &deck.main, &deck.extra, &deck.side }) {
 		for(auto& pcard : *plist) {
 			if(pcard->code == limitcode || pcard->alias == limitcode) {
-				if((it = filterList->content.find(pcard->code)) != endit)
-					limit = std::min(limit, it->second);
-				else if((it = filterList->content.find(pcard->alias)) != endit)
-					limit = std::min(limit, it->second);
+				if(!filterList->genesys) {
+					if((it = filterList->content.find(pcard->code)) != endit)
+						limit = std::min(limit, it->second);
+					else if((it = filterList->content.find(pcard->alias)) != endit)
+						limit = std::min(limit, it->second);
+				}
 				found++;
 			}
 			if(limit <= found)

gframe/deck_con.h

@@ -106,6 +106,9 @@ class DeckBuilder final : public irr::IEventReceiver {
 	DECLARE_WITH_CACHE(uint32_t, filter_scl)
 	DECLARE_WITH_CACHE(uint32_t, filter_marks)
 	DECLARE_WITH_CACHE(limitation_search_filters, filter_lm)
+	DECLARE_WITH_CACHE(uint32_t, filter_genesys_op)
+	DECLARE_WITH_CACHE(int32_t, filter_genesys_val1)
+	DECLARE_WITH_CACHE(int32_t, filter_genesys_val2)
 #undef DECLARE_WITH_CACHE
 
 	irr::core::vector2di mouse_pos;
@@ -142,6 +145,7 @@ class DeckBuilder final : public irr::IEventReceiver {
 	uint16_t side_monster_count;
 	uint16_t side_spell_count;
 	uint16_t side_trap_count;
+	int32_t genesys_points;
 	LFList* filterList;
 	std::map<std::wstring, std::vector<const CardDataC*>, std::less<>> searched_terms;
 	std::vector<const CardDataC*> results;