Salikh Gurgenidze
463 lines
15 KiB
Lua
463 lines
15 KiB
Lua
-- Guda Item Detection
|
|
-- Centralized item property detection with caching
|
|
-- Used by: CategoryManager, SortEngine, QuestItemBar, ItemButton, BagFrame, BankFrame
|
|
|
|
local addon = Guda
|
|
|
|
local ItemDetection = {}
|
|
addon.Modules.ItemDetection = ItemDetection
|
|
|
|
--=====================================================
|
|
-- Detection Result Caching
|
|
-- Caches tooltip scan results to avoid repeated scans
|
|
--=====================================================
|
|
local detectionCache = {}
|
|
local cacheHits = 0
|
|
local cacheMisses = 0
|
|
|
|
-- Clear the entire detection cache (use sparingly - only for major events)
|
|
-- For simple item moves, use InvalidateItem() or don't invalidate at all
|
|
function ItemDetection:ClearCache()
|
|
detectionCache = {}
|
|
cacheHits = 0
|
|
cacheMisses = 0
|
|
end
|
|
|
|
-- Invalidate a specific item from cache (by itemLink)
|
|
-- Use this when a specific item's properties might have changed
|
|
function ItemDetection:InvalidateItem(itemLink)
|
|
if itemLink then
|
|
detectionCache[itemLink] = nil
|
|
end
|
|
end
|
|
|
|
-- Invalidate multiple items from cache
|
|
-- Use this for batch operations
|
|
function ItemDetection:InvalidateItems(itemLinks)
|
|
if itemLinks then
|
|
for _, link in ipairs(itemLinks) do
|
|
if link then
|
|
detectionCache[link] = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Check if we have cached data for an item (useful for debugging)
|
|
function ItemDetection:IsCached(itemLink)
|
|
return itemLink and detectionCache[itemLink] ~= nil
|
|
end
|
|
|
|
-- Get cache statistics
|
|
function ItemDetection:GetCacheStats()
|
|
local total = cacheHits + cacheMisses
|
|
local hitRate = total > 0 and (cacheHits / total * 100) or 0
|
|
local size = 0
|
|
for _ in pairs(detectionCache) do size = size + 1 end
|
|
return {
|
|
hits = cacheHits,
|
|
misses = cacheMisses,
|
|
total = total,
|
|
hitRate = hitRate,
|
|
size = size,
|
|
}
|
|
end
|
|
|
|
-- Generate cache key for an item
|
|
local function GetCacheKey(itemLink)
|
|
if not itemLink then return nil end
|
|
return itemLink
|
|
end
|
|
|
|
--=====================================================
|
|
-- Tooltip Scanning Helpers
|
|
-- Uses shared tooltip from Utils module
|
|
--=====================================================
|
|
|
|
-- Scan tooltip and return all text lines
|
|
local function ScanTooltipLines(bagID, slotID, itemLink)
|
|
-- Use shared tooltip from Utils module
|
|
local tooltip, tooltipName = addon.Modules.Utils:GetScanTooltip()
|
|
|
|
-- Ensure tooltip owner is set before each scan
|
|
tooltip:SetOwner(WorldFrame, "ANCHOR_NONE")
|
|
tooltip:ClearLines()
|
|
|
|
-- Set tooltip based on what we have
|
|
if bagID and slotID then
|
|
if bagID == -1 then
|
|
-- Bank main bag: use SetInventoryItem (slot 39 + slotID)
|
|
if tooltip.SetInventoryItem then
|
|
tooltip:SetInventoryItem("player", 39 + slotID)
|
|
else
|
|
-- Fallback to hyperlink if SetInventoryItem not available
|
|
if itemLink then
|
|
tooltip:SetHyperlink(itemLink)
|
|
else
|
|
return {}
|
|
end
|
|
end
|
|
else
|
|
-- Regular bags and bank bags (5-11)
|
|
tooltip:SetBagItem(bagID, slotID)
|
|
end
|
|
elseif itemLink then
|
|
tooltip:SetHyperlink(itemLink)
|
|
else
|
|
return {}
|
|
end
|
|
|
|
local lines = {}
|
|
local numLines = tooltip:NumLines() or 0
|
|
|
|
for i = 1, numLines do
|
|
local leftLine = getglobal(tooltipName .. "TextLeft" .. i)
|
|
local rightLine = getglobal(tooltipName .. "TextRight" .. i)
|
|
|
|
local leftText = leftLine and leftLine:GetText() or ""
|
|
local rightText = rightLine and rightLine:GetText() or ""
|
|
|
|
-- Get left text colors (for detecting yellow/green/red text)
|
|
local lr, lg, lb, la = 1, 1, 1, 1
|
|
if leftLine and leftLine.GetTextColor then
|
|
lr, lg, lb, la = leftLine:GetTextColor()
|
|
end
|
|
|
|
-- Get right text colors (for detecting red requirements)
|
|
local rr, rg, rb, ra = 1, 1, 1, 1
|
|
if rightLine and rightLine.GetTextColor then
|
|
rr, rg, rb, ra = rightLine:GetTextColor()
|
|
end
|
|
|
|
table.insert(lines, {
|
|
left = leftText,
|
|
right = rightText,
|
|
leftLower = leftText and string.lower(leftText) or "",
|
|
rightLower = rightText and string.lower(rightText) or "",
|
|
r = lr, g = lg, b = lb,
|
|
rightR = rr, rightG = rg, rightB = rb,
|
|
})
|
|
end
|
|
|
|
return lines
|
|
end
|
|
|
|
--=====================================================
|
|
-- Core Detection Functions
|
|
--=====================================================
|
|
|
|
-- Check if item is a permanent enchant (enchanting scroll/vellum)
|
|
local function DetectPermanentEnchant(lines)
|
|
for _, line in ipairs(lines) do
|
|
if string.find(line.leftLower, "permanently") then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Check if item is a quest item and/or quest starter
|
|
local function DetectQuestItem(lines, itemData)
|
|
local isQuestItem = false
|
|
local isQuestStarter = false
|
|
|
|
-- Check item category first
|
|
if itemData and itemData.class == "Quest" then
|
|
isQuestItem = true
|
|
end
|
|
|
|
-- Scan tooltip for quest-related text
|
|
for _, line in ipairs(lines) do
|
|
local text = line.leftLower
|
|
|
|
-- Quest starter patterns (highest priority)
|
|
if string.find(text, "quest starter") or
|
|
string.find(text, "this item begins a quest") or
|
|
string.find(text, "begins a quest") or
|
|
string.find(text, "starts a quest") then
|
|
isQuestItem = true
|
|
isQuestStarter = true
|
|
end
|
|
|
|
-- Quest item patterns
|
|
if string.find(text, "quest item") then
|
|
isQuestItem = true
|
|
end
|
|
end
|
|
|
|
return isQuestItem, isQuestStarter
|
|
end
|
|
|
|
-- Check if item is junk (gray or white equippable without special properties)
|
|
local function DetectJunk(lines, itemData)
|
|
if not itemData then return false end
|
|
|
|
-- Ensure quality is a number
|
|
local quality = tonumber(itemData.quality)
|
|
local itemClass = itemData.class or ""
|
|
local itemSubclass = itemData.subclass or ""
|
|
local itemName = itemData.name or ""
|
|
local itemLink = itemData.link or ""
|
|
|
|
-- Gray items are always junk
|
|
-- Check quality value OR link color (gray = |cff9d9d9d)
|
|
if quality == 0 then
|
|
return true
|
|
end
|
|
|
|
-- Fallback: check link color for gray items
|
|
if itemLink and string.find(itemLink, "|cff9d9d9d") then
|
|
return true
|
|
end
|
|
|
|
-- If quality is still nil, try to determine from link color
|
|
if quality == nil then
|
|
if string.find(itemLink, "|cffffffff") then
|
|
quality = 1 -- White
|
|
else
|
|
return false -- Unknown quality, don't mark as junk
|
|
end
|
|
end
|
|
|
|
-- White equippable items might be junk
|
|
if quality == 1 and (itemClass == "Weapon" or itemClass == "Armor") then
|
|
-- Exclusions: trinkets, rings, necklaces, tabards, shirts
|
|
local subLower = string.lower(itemSubclass)
|
|
if string.find(subLower, "trinket") or
|
|
string.find(subLower, "ring") or
|
|
string.find(subLower, "neck") or
|
|
string.find(subLower, "tabard") or
|
|
string.find(subLower, "shirt") then
|
|
return false
|
|
end
|
|
|
|
-- Check for profession tools by common names
|
|
local nameLower = string.lower(itemName)
|
|
if string.find(nameLower, "mining pick") or
|
|
string.find(nameLower, "skinning knife") or
|
|
string.find(nameLower, "blacksmith hammer") or
|
|
string.find(nameLower, "fishing pole") or
|
|
string.find(nameLower, "gnomish army knife") then
|
|
return false
|
|
end
|
|
|
|
-- Check for profession tool subtype
|
|
if string.find(subLower, "fishing pole") or
|
|
string.find(subLower, "mining pick") or
|
|
string.find(subLower, "skinning knife") then
|
|
return false
|
|
end
|
|
|
|
-- Check tooltip for special text (Use:, Equip:, green text)
|
|
for _, line in ipairs(lines) do
|
|
local text = line.leftLower
|
|
|
|
-- Yellow text (Use:, Equip:)
|
|
if line.r and line.g and line.b then
|
|
local isYellow = (line.r > 0.9 and line.g > 0.75 and line.b < 0.2)
|
|
local isGreen = (line.r < 0.2 and line.g > 0.9 and line.b < 0.2)
|
|
|
|
if isYellow and (string.find(text, "use:") or string.find(text, "equip:")) then
|
|
return false
|
|
end
|
|
|
|
if isGreen then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
-- White equippable without special properties = junk
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
-- Check if item is usable for a quest (has yellow "Use:" text related to quest)
|
|
local function DetectQuestUsable(lines)
|
|
for _, line in ipairs(lines) do
|
|
-- Check for yellow "Use:" text
|
|
if line.r and line.g and line.b then
|
|
local isYellow = (line.r > 0.9 and line.g > 0.75 and line.b < 0.2)
|
|
if isYellow and string.find(line.leftLower, "use:") then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Durability pattern for filtering out broken item red text
|
|
local durabilityPattern = DURABILITY_TEMPLATE and string.gsub(DURABILITY_TEMPLATE, "%%d", "%%d+") or nil
|
|
|
|
-- Check if text color is red (unusable requirement)
|
|
local function IsRedColor(r, g, b)
|
|
if not r or not g or not b then return false end
|
|
-- RED_FONT_COLOR is typically (1.0, 0.1, 0.1)
|
|
local dr = math.abs(r - 1.0)
|
|
local dg = math.abs(g - 0.125)
|
|
local db = math.abs(b - 0.125)
|
|
return (dr < 0.15 and dg < 0.15 and db < 0.15)
|
|
end
|
|
|
|
-- Check if item is unusable (has red text indicating unmet requirements)
|
|
-- Excludes durability lines (broken items show red durability)
|
|
local function DetectUnusable(lines)
|
|
for _, line in ipairs(lines) do
|
|
if line.r and line.g and line.b then
|
|
-- Check for red text (requirements not met)
|
|
local isRed = IsRedColor(line.r, line.g, line.b) or
|
|
(line.r > 0.85 and line.g < 0.3 and line.b < 0.3)
|
|
|
|
if isRed then
|
|
local text = line.left or ""
|
|
-- Ignore durability lines (broken items)
|
|
if durabilityPattern and string.find(text, durabilityPattern) then
|
|
-- skip durability
|
|
else
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Also check right column (some requirements appear there)
|
|
if line.rightR and line.rightG and line.rightB then
|
|
local isRed = IsRedColor(line.rightR, line.rightG, line.rightB) or
|
|
(line.rightR > 0.85 and line.rightG < 0.3 and line.rightB < 0.3)
|
|
|
|
if isRed then
|
|
local text = line.right or ""
|
|
if durabilityPattern and string.find(text, durabilityPattern) then
|
|
-- skip durability
|
|
else
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--=====================================================
|
|
-- Public API - Cached Detection
|
|
--=====================================================
|
|
|
|
-- Get all item properties at once (cached)
|
|
-- Returns: { isQuestItem, isQuestStarter, isQuestUsable, isJunk, isPermanentEnchant, isUnusable }
|
|
function ItemDetection:GetItemProperties(itemData, bagID, slotID)
|
|
if not itemData then
|
|
return {
|
|
isQuestItem = false,
|
|
isQuestStarter = false,
|
|
isQuestUsable = false,
|
|
isJunk = false,
|
|
isPermanentEnchant = false,
|
|
isUnusable = false,
|
|
}
|
|
end
|
|
|
|
local itemLink = itemData.link
|
|
local cacheKey = GetCacheKey(itemLink)
|
|
|
|
-- Check cache
|
|
if cacheKey and detectionCache[cacheKey] then
|
|
cacheHits = cacheHits + 1
|
|
return detectionCache[cacheKey]
|
|
end
|
|
cacheMisses = cacheMisses + 1
|
|
|
|
-- Scan tooltip once
|
|
local lines = ScanTooltipLines(bagID, slotID, itemLink)
|
|
|
|
-- Debug: log if tooltip scan failed
|
|
if table.getn(lines) == 0 and addon.DEBUG then
|
|
addon:Debug("ItemDetection: No tooltip lines for %s (bag=%s, slot=%s)",
|
|
tostring(itemData.name or itemLink), tostring(bagID), tostring(slotID))
|
|
end
|
|
|
|
-- Detect all properties
|
|
local isPermanentEnchant = DetectPermanentEnchant(lines)
|
|
local isQuestItem, isQuestStarter = DetectQuestItem(lines, itemData)
|
|
local isQuestUsable = DetectQuestUsable(lines)
|
|
local isJunk = DetectJunk(lines, itemData)
|
|
local isUnusable = DetectUnusable(lines)
|
|
|
|
-- Debug: log junk detection for gray items
|
|
if addon.DEBUG then
|
|
local quality = tonumber(itemData.quality)
|
|
local linkHasGray = itemLink and string.find(itemLink, "|cff9d9d9d")
|
|
if quality == 0 or linkHasGray then
|
|
addon:Debug("ItemDetection JUNK: %s quality=%s linkGray=%s isJunk=%s",
|
|
tostring(itemData.name), tostring(quality), tostring(linkHasGray), tostring(isJunk))
|
|
end
|
|
end
|
|
|
|
-- Permanent enchants are NOT quest items (even if categorized as Quest)
|
|
if isPermanentEnchant then
|
|
isQuestItem = false
|
|
isQuestStarter = false
|
|
isQuestUsable = false
|
|
end
|
|
|
|
local result = {
|
|
isQuestItem = isQuestItem,
|
|
isQuestStarter = isQuestStarter,
|
|
isQuestUsable = isQuestUsable,
|
|
isJunk = isJunk,
|
|
isPermanentEnchant = isPermanentEnchant,
|
|
isUnusable = isUnusable,
|
|
}
|
|
|
|
-- Cache result
|
|
if cacheKey then
|
|
detectionCache[cacheKey] = result
|
|
end
|
|
|
|
return result
|
|
end
|
|
|
|
-- Convenience functions for single property checks
|
|
function ItemDetection:IsQuestItem(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isQuestItem, props.isQuestStarter
|
|
end
|
|
|
|
function ItemDetection:IsQuestStarter(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isQuestStarter
|
|
end
|
|
|
|
function ItemDetection:IsQuestUsable(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isQuestUsable
|
|
end
|
|
|
|
function ItemDetection:IsJunk(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isJunk
|
|
end
|
|
|
|
function ItemDetection:IsPermanentEnchant(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isPermanentEnchant
|
|
end
|
|
|
|
function ItemDetection:IsUnusable(itemData, bagID, slotID)
|
|
local props = self:GetItemProperties(itemData, bagID, slotID)
|
|
return props.isUnusable
|
|
end
|
|
|
|
--=====================================================
|
|
-- Initialization
|
|
--=====================================================
|
|
|
|
function ItemDetection:Initialize()
|
|
-- Clear cache when entering world (character switch)
|
|
addon.Modules.Events:Register("PLAYER_ENTERING_WORLD", function()
|
|
self:ClearCache()
|
|
end, "ItemDetection")
|
|
|
|
addon:Debug("ItemDetection module initialized")
|
|
end
|