display affix rolls/tier

Source/diablo.cpp

@@ -1800,6 +1800,13 @@ void InitKeymapActions()
 	    DoAutoMap,
 	    nullptr,
 	    IsGameRunning);
+	sgOptions.Keymapper.AddAction(
+	    "Show Affix Data",
+	    N_("Show affix data"),
+	    N_("Shows detailed affix data while held."),
+	    SDLK_LCTRL,
+	    [] { showDetailedAffixData = true; },
+	    [] { showDetailedAffixData = false; });
 	sgOptions.Keymapper.AddAction(
 	    "CycleAutomapType",
 	    N_("Cycle map type"),

Source/itemdat.cpp

@@ -31,6 +31,9 @@ std::vector<PLStruct> ItemPrefixes;
 /** Contains the data related to each item suffix. */
 std::vector<PLStruct> ItemSuffixes;
 
+std::unordered_map<uint32_t, std::pair<const PLStruct *, const PLStruct *>> affixDataCache;
+bool showDetailedAffixData = false;
+
 namespace {
 
 tl::expected<item_drop_rate, std::string> ParseItemDropRate(std::string_view value)
@@ -619,6 +622,52 @@ void LoadItemAffixesDat(std::string_view filename, std::vector<PLStruct> &out)
 	out.shrink_to_fit();
 }
 
+
+
+void generateAffixDataMap()
+{
+	struct AffixMinMaxRolls {
+		std::string name;
+		int minRoll;
+		int maxRoll;
+	};
+
+	std::unordered_map<item_effect_type, std::vector<AffixMinMaxRolls>> m;
+	std::unordered_map<std::string, std::pair<uint8_t, uint8_t>> m2;
+	auto fillAffixDataMap = [&m](std::vector<PLStruct> &out) {
+		for (const auto &affix : out) {
+			m[affix.power.type].push_back({ affix.PLName, affix.power.param1, affix.power.param2 });
+		}
+	};
+
+	fillAffixDataMap(ItemPrefixes);
+	fillAffixDataMap(ItemSuffixes);
+
+	for (auto &[key, val] : m) {
+		std::sort(val.begin(), val.end(), [](const auto &lhs, const auto &rhs) {
+			return std::abs(lhs.minRoll) < std::abs(rhs.minRoll);
+		});
+
+		uint8_t num = 0;
+		for (const auto& affix : val) {
+			auto &affixData = m2[affix.name];
+			affixData = {
+				++num, static_cast<uint8_t>(val.size())
+			};
+		}
+	}
+
+	auto addAffixTierData = [&m, &m2](auto& affixVector) {
+		for (auto &affix : affixVector) {
+			auto &affixData = m[affix.power.type];
+			const auto &data = m2[affix.PLName];
+			affix.currentTier = data.first;
+			affix.maxTier = data.second;
+		}
+	};
+	addAffixTierData(ItemPrefixes);
+	addAffixTierData(ItemSuffixes);
+}
 } // namespace
 
 void LoadItemData()
@@ -627,6 +676,8 @@ void LoadItemData()
 	LoadUniqueItemDat();
 	LoadItemAffixesDat("txtdata\\items\\item_prefixes.tsv", ItemPrefixes);
 	LoadItemAffixesDat("txtdata\\items\\item_suffixes.tsv", ItemSuffixes);
+
+	generateAffixDataMap();
 }
 
 std::string_view ItemTypeToString(ItemType itemType)

Source/itemdat.h

@@ -633,6 +633,8 @@ struct PLStruct {
 	int minVal;
 	int maxVal;
 	int multVal;
+	uint8_t currentTier;
+	uint8_t maxTier;
 };
 
 struct UniqueItem {
@@ -650,6 +652,9 @@ extern std::vector<PLStruct> ItemPrefixes;
 extern std::vector<PLStruct> ItemSuffixes;
 extern std::vector<UniqueItem> UniqueItems;
 
+extern std::unordered_map<uint32_t, std::pair<const PLStruct *, const PLStruct *>> affixDataCache;
+extern bool showDetailedAffixData;
+
 void LoadItemData();
 
 } // namespace devilution

Source/items.cpp

@@ -2428,6 +2428,7 @@ std::string GetTranslatedItemNameMagical(const Item &item, bool hellfireItem, bo
 		if (forceNameLengthCheck ? *forceNameLengthCheck : !StringInPanel(identifiedName.c_str())) {
 			identifiedName = GenerateMagicItemName(_(baseItemData.iSName), pPrefix, pSufix, translate);
 		}
+		affixDataCache[item._iSeed] = {pPrefix, pSufix};
 	}
 
 	SetRndSeed(currentSeed);
@@ -3819,7 +3820,7 @@ bool DoOil(Player &player, int cii)
 	return true;
 }
 
-[[nodiscard]] StringOrView PrintItemPower(char plidx, const Item &item)
+[[nodiscard]] StringOrView PrintItemPowerRaw(char plidx, const Item &item)
 {
 	switch (plidx) {
 	case IPL_TOHIT:
@@ -4026,6 +4027,24 @@ bool DoOil(Player &player, int cii)
 	}
 }
 
+[[nodiscard]] StringOrView PrintItemPower(char plidx, const Item &item)
+{
+	if (showDetailedAffixData && item._iMagical == ITEM_QUALITY_MAGIC && item._iIdentified) {
+		if (auto cache = affixDataCache.find(item._iSeed); cache != affixDataCache.end()) {
+			const auto &[prefix, suffix] = cache->second;
+			const PLStruct *affix = prefix != nullptr && prefix->power.type == plidx ? prefix : suffix;
+			std::stringstream rolls;
+			if (affix->power.param1 != affix->power.param2 && affix->power.param2 != 0)
+			rolls << "stat range [" << affix->power.param1 << "/" << affix->power.param2 << "] ";
+
+			std::stringstream tier;
+			tier << "| tier [" << static_cast<unsigned>(affix->currentTier) << "/" << static_cast<unsigned>(affix->maxTier) << "]";
+			return rolls.str() + tier.str();
+		}
+	}
+	return PrintItemPowerRaw(plidx, item);
+}
+
 void DrawUniqueInfo(const Surface &out)
 {
 	const Point position = DrawUniqueInfoWindow(out);