Files

691 lines
26 KiB
Lua

-- Step 1: reads an item tooltip and turns it into a table.
-- Parse() works on plain text lines, so it can be tested without the game.
--
-- item = {
-- name, quality (0-5), slot ("CHEST", "ONEHAND", "TWOHAND", "FINGER" ...), slotText,
-- armorKind ("Cloth" "Leather" "Mail" "Plate" "Shield" "Libram" "Idol" "Totem"),
-- weaponKind ("Sword" "Dagger" "Bow" "Wand" ...),
-- weapon = { min, max, speed, dps, school },
-- stats = { STR=, AGI=, STA=, INT=, SPI=, ARMOR=, AP=, SP=, HEAL=, CRIT=, HIT=, MP5=, ... },
-- reqLevel, classes = { PRIEST = true }, setName, setBonus = { lines },
-- special = { "Equip: ...", "Use: ..." } -- effects that are not numbers we understand
-- unparsed = { "..." } -- lines we could not read at all
-- }
local AG = AdeGear
local Items = {}
AG.Items = Items
local STATS = { Strength = "STR", Agility = "AGI", Stamina = "STA", Intellect = "INT", Spirit = "SPI" }
local ENCHANT = { Armor = "ARMOR", Health = "HEALTH", Mana = "MANA", Defense = "DEFENSE" }
local SLOT_TEXT = {
["Head"] = "HEAD", ["Neck"] = "NECK", ["Shoulder"] = "SHOULDER", ["Back"] = "BACK",
["Chest"] = "CHEST", ["Robe"] = "CHEST", ["Shirt"] = "SHIRT", ["Tabard"] = "TABARD",
["Wrist"] = "WRIST", ["Hands"] = "HANDS", ["Waist"] = "WAIST", ["Legs"] = "LEGS",
["Feet"] = "FEET", ["Finger"] = "FINGER", ["Trinket"] = "TRINKET",
["One-Hand"] = "ONEHAND", ["Two-Hand"] = "TWOHAND", ["Main Hand"] = "MAINHAND",
["Off Hand"] = "OFFHAND", ["Held In Off-hand"] = "HELD",
["Ranged"] = "RANGED", ["Thrown"] = "RANGED", ["Relic"] = "RANGED",
}
local WEAPON_KIND = {
["Axe"] = 1, ["Mace"] = 1, ["Sword"] = 1, ["Dagger"] = 1, ["Fist Weapon"] = 1, ["Polearm"] = 1,
["Staff"] = 1, ["Bow"] = 1, ["Crossbow"] = 1, ["Gun"] = 1, ["Wand"] = 1, ["Thrown"] = 1,
["Fishing Pole"] = 1, ["Miscellaneous"] = 1,
}
local ARMOR_KIND = {
["Cloth"] = 1, ["Leather"] = 1, ["Mail"] = 1, ["Plate"] = 1, ["Shield"] = 1,
["Idol"] = 1, ["Libram"] = 1, ["Totem"] = 1, ["Miscellaneous"] = 1,
}
-- "Equip:" lines whose numbers we understand: { pattern, stat key }
local EQUIP = {
{ "^Equip: When struck in combat inflicts (%d+) %a+ damage to the attacker%.?$", "THORNS" },
{ "^Equip: Increases attack power by (%d+)%.?$", "AP" },
{ "^Equip: %+(%d+) Attack Power%.?$", "AP" },
{ "^Equip: Increases ranged attack power by (%d+)%.?$", "RAP" },
{ "^Equip: %+(%d+) ranged Attack Power%.?$", "RAP" },
{ "^Equip: Increases damage and healing done by magical spells and effects by up to (%d+)%.?$", "SP" },
{ "^Equip: Increases healing done by spells and effects by up to (%d+)%.?$", "HEAL" },
{ "^Equip: Improves your chance to get a critical strike with spells by (%d+%.?%d*)%%%.?$", "SPELLCRIT" },
{ "^Equip: Improves your chance to hit with spells by (%d+%.?%d*)%%%.?$", "SPELLHIT" },
{ "^Equip: Improves your chance to get a critical strike by (%d+%.?%d*)%%%.?$", "CRIT" },
{ "^Equip: Improves your chance to hit by (%d+%.?%d*)%%%.?$", "HIT" },
{ "^Equip: Restores (%d+) mana per 5 sec%.?$", "MP5" },
{ "^Equip: Allows (%d+)%% of your Mana regeneration to continue while casting%.?$", "CASTREGEN" },
{ "^Equip: Restores (%d+) health per 5 sec%.?$", "HP5" },
{ "^Equip: Increases your chance to dodge an attack by (%d+%.?%d*)%%%.?$", "DODGE" },
{ "^Equip: Increases your chance to parry an attack by (%d+%.?%d*)%%%.?$", "PARRY" },
{ "^Equip: Increases your chance to block attacks with a shield by (%d+%.?%d*)%%%.?$", "BLOCK" },
{ "^Equip: Increases the block value of your shield by (%d+)%.?$", "BLOCKVAL" },
{ "^Equip: Increased Defense %+(%d+)%.?$", "DEFENSE" },
}
-- plain lines (enchants and base values): { pattern, stat key }
local PLAIN = {
{ "^(%d+) Armor$", "ARMOR" },
{ "^%+(%d+) Armor$", "ARMOR" },
{ "^Armor %+(%d+)$", "ARMOR" },
{ "^Health %+(%d+)$", "HEALTH" },
{ "^(%d+) Block$", "BLOCKVAL" },
{ "^%+(%d+) Attack Power$", "AP" },
{ "^%+(%d+) Healing Spells$", "HEAL" },
{ "^%+(%d+) Spell Damage$", "SP" },
{ "^%+(%d+) Mana$", "MANA" },
{ "^%+(%d+) Health$", "HEALTH" },
{ "^%+(%d+) Defense$", "DEFENSE" },
{ "^Mana Regen %+(%d+) per 5 sec%.?$", "MP5" },
{ "^%+(%d+) health every 5 sec%.?$", "HP5" },
{ "^%+(%d+) mana every 5 sec%.?$", "MP5" },
}
local SKIP = {
"^Binds when", "^Soulbound", "^Unique", "^Durability", "^Quest Item", "^Conjured", "^Sell Price",
"^Heroic", "^Requires Level", "^Classes:", "^\"", "^Item Level", "^This Item Begins",
"^<Right Click", "^Right Click", "^Not yet", "^Already known", "^Cooldown", "^Charges",
-- reputation requirement: "Requires Wildhammer Clan -- Revered"
"^Requires .+ %-%- Neutral", "^Requires .+ %-%- Friendly", "^Requires .+ %-%- Honored",
"^Requires .+ %-%- Revered", "^Requires .+ %-%- Exalted",
-- tools and shield spikes, nothing to value
"^Mining %+", "^Skinning %+", "^Herbalism %+", "^Fishing %+", "^Iron Spike",
}
local function Clean(t)
if not t then return "" end
t = string.gsub(t, "|c%x%x%x%x%x%x%x%x", "")
t = string.gsub(t, "|r", "")
t = string.gsub(t, "^%s+", "")
t = string.gsub(t, "%s+$", "")
return t
end
local function Add(stats, key, value)
stats[key] = (stats[key] or 0) + value
end
-- quality from the color of the name line
function Items.QualityOf(c)
if not c then return 1 end
local best, bestD = 1, 99
for q = 0, 5 do
local qc = AG.Q[q]
local d = math.abs(qc[1] - c[1]) + math.abs(qc[2] - c[2]) + math.abs(qc[3] - c[3])
if d < bestD then best, bestD = q, d end
end
return best
end
local function UpperKey(text)
text = string.upper(text)
text = string.gsub(text, "[^%w]+", "_")
return text
end
local function ClassList(text)
local set = {}
for name in string.gfind(text, "(%a+)") do
set[string.upper(name)] = true
end
return set
end
local ParseText
-- stats of a short text such as "+15 Strength." or "Improves your chance to hit by 1%."
local function StatsOfText(text)
local plain = string.gsub(text, "%.$", "")
local tmp = { stats = {}, special = {}, unparsed = {}, reqLevel = 0 }
ParseText(tmp, plain)
if next(tmp.stats) then return tmp.stats, true end
tmp = { stats = {}, special = {}, unparsed = {}, reqLevel = 0 }
ParseText(tmp, "Equip: " .. text)
if next(tmp.stats) then return tmp.stats, true end
return {}, false
end
-- set bonus line: "(6) Set: ..." (needs 6 pieces) or "Set: ..." (already active)
local function SetLine(it, t, c)
local s, e, n, text = string.find(t, "^%((%d+)%) Set: (.+)$")
local active
if s then
n = tonumber(n)
else
s, e, text = string.find(t, "^Set: (.+)$")
if not s then return false end
n = nil
active = true
end
it.set = it.set or { pieces = {}, bonuses = {} }
if active == nil then
active = false
if c and c[2] > c[1] + 0.3 then active = true end
end
local stats, ok = StatsOfText(text)
-- a bonus that is switched off shows how many pieces it needs; a switched on one does not. The number
-- is remembered the first time it is seen, so later the addon knows when a bonus would stop.
local setName = it.set.name
if setName and AdeGearDB then
AdeGearDB.setN = AdeGearDB.setN or {}
local key = setName .. "|" .. text
if n then AdeGearDB.setN[key] = n elseif AdeGearDB.setN[key] then n = AdeGearDB.setN[key] end
-- the fewest pieces it was ever seen switched on with is an upper limit for its number
if active and it.set.have then
AdeGearDB.setMin = AdeGearDB.setMin or {}
local old = AdeGearDB.setMin[key]
if not old or it.set.have < old then AdeGearDB.setMin[key] = it.set.have end
end
end
local minHave = nil
if setName and AdeGearDB and AdeGearDB.setMin then minHave = AdeGearDB.setMin[setName .. "|" .. text] end
table.insert(it.set.bonuses, { n = n, text = text, active = active, stats = stats, understood = ok, minHave = minHave })
it.set.inList = false
return true
end
-- true when the line was understood (stats, requirements, ...)
-- c is the color of the line (set pieces and set bonuses use it)
ParseText = function(it, t, c)
local s, e, c1, c2, c3
-- names of the set pieces follow the set header; yellow = equipped
if it.set and it.set.inList then
if SetLine(it, t, c) then return true end
local have = false
if c and c[1] > 0.7 then have = true end
table.insert(it.set.pieces, { name = t, equipped = have })
return true
end
if SetLine(it, t, c) then return true end
s, e, c1, c2 = string.find(t, "^Requires (.+) %((%d+)%)$")
if s and not string.find(t, ",") then
it.reqSkill = { name = c1, level = tonumber(c2) }
return true
end
for i = 1, table.getn(SKIP) do
if string.find(t, SKIP[i]) then
-- keep the numbers of these two
s, e, c1 = string.find(t, "^Requires Level (%d+)")
if s then it.reqLevel = tonumber(c1) end
s, e, c1 = string.find(t, "^Classes: (.+)$")
if s then it.classes = ClassList(c1) end
return true
end
end
-- haste: "Increases your attack and casting speed by 1%", only attack speed, only casting speed
s, e, c1 = string.find(t, "^Equip: Increases your attack and casting speed by (%d+%.?%d*)%%%.?$")
if s then
Add(it.stats, "HASTE_ATTACK", tonumber(c1))
Add(it.stats, "HASTE_CAST", tonumber(c1))
return true
end
s, e, c1 = string.find(t, "^Equip: Increases your attack speed by (%d+%.?%d*)%%%.?$")
if s then Add(it.stats, "HASTE_ATTACK", tonumber(c1)) return true end
s, e, c1 = string.find(t, "^Equip: Increases your casting speed by (%d+%.?%d*)%%%.?$")
if s then Add(it.stats, "HASTE_CAST", tonumber(c1)) return true end
-- life steal: "1% of damage dealt is returned as healing."
s, e, c1 = string.find(t, "^Equip: (%d+%.?%d*)%% of damage dealt is returned as healing%.?$")
if s then Add(it.stats, "LIFESTEAL", tonumber(c1)) return true end
-- armor penetration: "Your attacks ignore 10 of the target's armor."
s, e, c1 = string.find(t, "^Equip: Your attacks ignore (%d+) of the target's armor%.?$")
if s then Add(it.stats, "ARMORPEN", tonumber(c1)) return true end
s, e, c1 = string.find(t, "^Adds (%d+%.?%d*) damage per second%.?$")
if s then it.ammoDps = tonumber(c1) return true end
s, e, c1 = string.find(t, "^%((%d+%.?%d*) damage per second%)$")
if s then it.dps = tonumber(c1) return true end
s, e, c1, c2 = string.find(t, "^%+%s*(%d+) %- (%d+) (%a+) Damage$")
if s then
it.weapon = it.weapon or {}
it.weapon.extra = (it.weapon.extra or 0) + (tonumber(c1) + tonumber(c2)) / 2
return true
end
-- stat lines: +5 Agility, -3 Spirit
s, e, c1, c2, c3 = string.find(t, "^([%+%-])(%d+) (%a+)$")
if s and STATS[c3] then
local v = tonumber(c2)
if c1 == "-" then v = -v end
Add(it.stats, STATS[c3], v)
return true
end
-- enchant lines (green, after the stats): "Stamina +1", "Armor +30", "Fire Resistance +5"
s, e, c1, c2 = string.find(t, "^(%a+) %+(%d+)$")
if s then
local key = STATS[c1] or ENCHANT[c1]
if key then Add(it.stats, key, tonumber(c2)) return true end
end
s, e, c1, c2 = string.find(t, "^(%a+) Resistance %+(%d+)$")
if s and (c1 == "Fire" or c1 == "Frost" or c1 == "Nature" or c1 == "Shadow" or c1 == "Arcane") then
Add(it.stats, "RES_" .. string.upper(c1), tonumber(c2))
return true
end
-- resistance, also a minus ("-6 Fire Resistance")
s, e, c1, c2, c3 = string.find(t, "^([%+%-])(%d+) (%a+) Resistance$")
if s then
local v = tonumber(c2)
if c1 == "-" then v = -v end
Add(it.stats, "RES_" .. string.upper(c3), v)
return true
end
-- spell damage of one school written plainly: "+14 Arcane Spell Damage"
s, e, c1, c2 = string.find(t, "^%+(%d+) (%a+) Spell Damage$")
if s and (c2 == "Arcane" or c2 == "Fire" or c2 == "Frost" or c2 == "Holy" or c2 == "Nature" or c2 == "Shadow") then
Add(it.stats, "DMG_" .. string.upper(c2), tonumber(c1))
return true
end
-- weapon enchant: "Weapon Damage +1" adds to every hit
s, e, c1 = string.find(t, "^Weapon Damage %+(%d+)$")
if s then
it.weapon = it.weapon or {}
it.weapon.extra = (it.weapon.extra or 0) + tonumber(c1)
return true
end
s, e, c1 = string.find(t, "^%+(%d+) All Resistances$")
if s then
local list = { "FIRE", "FROST", "NATURE", "SHADOW", "ARCANE" }
for i = 1, 5 do Add(it.stats, "RES_" .. list[i], tonumber(c1)) end
return true
end
-- armor kit: "Reinforced Armor +24" or "Reinforced Armor +24/+3 Stamina"
s, e, c1, c2, c3 = string.find(t, "^Reinforced Armor %+(%d+)/%+(%d+) (%a+)$")
if s and STATS[c3] then
Add(it.stats, "ARMOR", tonumber(c1))
Add(it.stats, STATS[c3], tonumber(c2))
return true
end
s, e, c1 = string.find(t, "^Reinforced Armor %+(%d+)$")
if s then Add(it.stats, "ARMOR", tonumber(c1)) return true end
for i = 1, table.getn(PLAIN) do
s, e, c1 = string.find(t, PLAIN[i][1])
if s then Add(it.stats, PLAIN[i][2], tonumber(c1)) return true end
end
for i = 1, table.getn(EQUIP) do
s, e, c1 = string.find(t, EQUIP[i][1])
if s then Add(it.stats, EQUIP[i][2], tonumber(c1)) return true end
end
s, e, c1, c2 = string.find(t, "^Equip: Increases damage done by (%a+) spells and effects by up to (%d+)%.?$")
if s then Add(it.stats, "DMG_" .. string.upper(c1), tonumber(c2)) return true end
s, e, c1, c2 = string.find(t, "^Equip: Increased (.+) %+(%d+)%.?$")
if s then Add(it.stats, "SKILL_" .. UpperKey(c1), tonumber(c2)) return true end
-- bonus that works only in druid forms
s, e, c1 = string.find(t, "^Equip: %+(%d+) Attack Power in Cat, Bear, Dire Bear, and Moonkin forms only%.?$")
if s then Add(it.stats, "FERAL_AP", tonumber(c1)) return true end
-- any other "Equip: +5 All Resistances." style line: read it like the same line without "Equip:"
s, e, c1 = string.find(t, "^Equip: (.+)$")
if s then
local plain = string.gsub(c1, "%.$", "")
local tmp = { stats = {}, special = {}, unparsed = {}, reqLevel = 0 }
ParseText(tmp, plain)
if next(tmp.stats) then
for k, v in pairs(tmp.stats) do Add(it.stats, k, v) end
return true
end
end
-- "60 to 100 Shadow damage": the middle value counts (the plain pattern below would take the 100)
local lo, hi
s, e, lo, hi = string.find(t, "^Chance on hit: .-(%d+) to (%d+) %a+ damage")
if s then
Add(it.stats, "PROC_DMG", (tonumber(lo) + tonumber(hi)) / 2)
table.insert(it.special, t)
return true
end
s, e, c1 = string.find(t, "^Chance on hit: .-(%d+) %a+ damage")
if s then
Add(it.stats, "PROC_DMG", tonumber(c1))
table.insert(it.special, t)
return true
end
if string.find(t, "^Equip:") or string.find(t, "^Use:") or string.find(t, "^Chance on hit:") then
table.insert(it.special, t)
return true
end
s, e, c1 = string.find(t, "^(%d+) Slot (.+)$")
if s then it.bag = true return true end
-- set header: "Dragonmaw Battlegarb (4/7)", 4 pieces equipped of 7
s, e, c1, c2, c3 = string.find(t, "^(.+) %((%d+)/(%d+)%)$")
if s then
it.set = it.set or { pieces = {}, bonuses = {} }
it.set.name, it.set.have, it.set.total = c1, tonumber(c2), tonumber(c3)
it.set.inList = true
return true
end
return false
end
-- lines: { { l = left text, r = right text or nil, c = { r, g, b } of the left text }, ... }
local function ParseLines(lines)
local n = table.getn(lines)
if n == 0 then return nil end
local it = { stats = {}, special = {}, unparsed = {}, reqLevel = 0 }
it.name = Clean(lines[1].l)
it.quality = Items.QualityOf(lines[1].c)
for i = 2, n do
local l, r = Clean(lines[i].l), Clean(lines[i].r)
if l ~= "" or r ~= "" then
local handled = false
if l ~= "" and r ~= "" then
local s, e, c1, c2, c3
local sp = nil
s, e, sp = string.find(r, "^Speed (%d+%.?%d*)$")
if s then
s, e, c1, c2 = string.find(l, "^(%d+) %- (%d+) Damage$")
if s then
it.weapon = it.weapon or {}
it.weapon.min, it.weapon.max, it.weapon.speed = tonumber(c1), tonumber(c2), tonumber(sp)
handled = true
else
s, e, c1, c2, c3 = string.find(l, "^(%d+) %- (%d+) (%a+) Damage$")
if s then
it.weapon = it.weapon or {}
it.weapon.min, it.weapon.max, it.weapon.speed = tonumber(c1), tonumber(c2), tonumber(sp)
it.weapon.school = c3
handled = true
end
end
elseif SLOT_TEXT[l] and not it.slot then
it.slot = SLOT_TEXT[l]
it.slotText = l
if WEAPON_KIND[r] then it.weaponKind = r end
if ARMOR_KIND[r] then it.armorKind = r end
handled = true
end
elseif l ~= "" and r == "" then
if SLOT_TEXT[l] and not it.slot then
it.slot = SLOT_TEXT[l]
it.slotText = l
if l == "Thrown" then it.weaponKind = "Thrown" end
handled = true
elseif (l == "Wand" or l == "Bow" or l == "Gun" or l == "Crossbow") and not it.slot then
-- some tooltips show only the kind of a ranged weapon
it.slot = "RANGED"
it.slotText = "Ranged"
it.weaponKind = l
handled = true
else
handled = ParseText(it, l, lines[i].c)
end
end
if not handled then
local text = l
if r ~= "" then text = l .. " | " .. r end
table.insert(it.unparsed, text)
end
end
end
if it.set then it.set.inList = nil end
-- ammunition: "Adds 12.5 damage per second", no slot line. Arrow or bullet from the name if the type is unknown.
if it.ammoDps and not it.slot then
it.slot = "AMMO"
it.slotText = "Ammo"
if string.find(it.name, "Arrow") then it.ammoKind = "Arrow"
elseif string.find(it.name, "Bullet") or string.find(it.name, "Shot") then it.ammoKind = "Bullet" end
end
if it.weapon and it.weapon.min then
it.weapon.avg = (it.weapon.min + it.weapon.max) / 2
it.weapon.dps = (it.weapon.avg + (it.weapon.extra or 0)) / it.weapon.speed
if it.dps then it.weapon.dps = it.dps end
end
return it
end
----------------------------------------------------------------------
-- Reading tooltips of the game
----------------------------------------------------------------------
local tip = CreateFrame("GameTooltip", "AdeGearScanTip", UIParent, "GameTooltipTemplate")
local MAXLINES = 40
-- the tooltip keeps old right-hand text, so every line is emptied first
local function Scrub()
tip:ClearLines()
for i = 1, MAXLINES do
local left = getglobal("AdeGearScanTipTextLeft" .. i)
local right = getglobal("AdeGearScanTipTextRight" .. i)
if left then left:SetText("") end
if right then right:SetText("") end
end
end
-- Plans, Pattern, Recipe, Formula, Schematic: the tooltip of a recipe also shows the item it makes.
-- We judge that item, not the recipe. Falls back to the recipe itself if the item is not shown.
local RECIPE = { "^Plans?: ", "^Pattern: ", "^Recipe: ", "^Formula: ", "^Schematic: ", "^Design: " }
function Items.Parse(lines)
local n = table.getn(lines)
if n > 3 then
local name = Clean(lines[1].l)
local isRecipe = false
for k = 1, table.getn(RECIPE) do
if string.find(name, RECIPE[k]) then isRecipe = true end
end
if isRecipe then
local use = nil
for k = 2, n do
if string.find(Clean(lines[k].l), "^Use: Teaches you how to") then use = k break end
end
if use then
local first = nil
for k = use + 1, n do
if Clean(lines[k].l) ~= "" then first = k break end
end
if first then
local sub = {}
for k = first, n do
local t = Clean(lines[k].l)
if k > first and string.find(t, "^Requires .+%(%d+%)") then break end
table.insert(sub, lines[k])
end
if table.getn(sub) > 1 then
local it = ParseLines(sub)
if it and it.slot then
it.recipe = name
return it
end
end
end
end
end
end
return ParseLines(lines)
end
local function ReadLines()
local lines = {}
for i = 1, tip:NumLines() do
local left = getglobal("AdeGearScanTipTextLeft" .. i)
local right = getglobal("AdeGearScanTipTextRight" .. i)
local l = left and left:GetText()
local r = right and right:GetText()
local c = nil
if left then
local cr, cg, cb = left:GetTextColor()
if cr then c = { cr, cg, cb } end
end
if r == "" then r = nil end
table.insert(lines, { l = l, r = r, c = c })
end
return lines
end
-- "item:id:enchant:suffix:unique" from a link or an item string
function Items.ItemString(link)
if not link then return nil end
local s, e, str = string.find(link, "(item:%d+:%d+:%d+:%d+)")
if str then return str end
s, e, str = string.find(link, "(item:%d+)")
return str
end
local cache = {}
function Items.FromLink(link)
local str = Items.ItemString(link)
if not str then return nil end
if cache[str] then return cache[str] end
tip:SetOwner(UIParent, "ANCHOR_NONE")
Scrub()
tip:SetHyperlink(str)
local lines = ReadLines()
if AdeGearDB and AdeGearDB.dumpLines then Items.DumpLines(str, lines) end
local meta
if AG.Ru then lines, meta = AG.Ru.Lines(lines, str) end
local it = Items.Parse(lines)
if it and meta then it.ru = true; it.typeUnknown = meta.typeUnknown; it.orig = meta.orig end
tip:Hide()
if it and it.name ~= "" then
it.link = str
local _, _, _, _, itype, subtype, _, _, texture = GetItemInfo(str)
it.icon = texture
if itype == "Projectile" then
it.slot = "AMMO"
it.slotText = "Ammo"
if subtype == "Arrow" or subtype == "Bullet" then it.ammoKind = subtype end
end
-- set pieces are read again every time: how many pieces you wear (and which bonuses are on) changes with your gear
if not it.set then cache[str] = it end
return it
end
return nil
end
-- equipped item of the player by inventory slot id (not cached: gear changes)
function Items.FromSlot(id)
tip:SetOwner(UIParent, "ANCHOR_NONE")
Scrub()
local has = tip:SetInventoryItem("player", id)
if not has then
tip:Hide()
return nil
end
local lines = ReadLines()
local meta
if AG.Ru then lines, meta = AG.Ru.Lines(lines, GetInventoryItemLink("player", id)) end
local it = Items.Parse(lines)
if it and meta then it.ru = true; it.typeUnknown = meta.typeUnknown; it.orig = meta.orig end
tip:Hide()
if it then
it.link = GetInventoryItemLink("player", id)
it.icon = GetInventoryItemTexture("player", id)
if id == 0 and it.link then
local _, _, _, _, itype, subtype = GetItemInfo(Items.ItemString(it.link) or it.link)
if itype == "Projectile" and (subtype == "Arrow" or subtype == "Bullet") then it.ammoKind = subtype end
end
it.equippedSlot = id
end
return it
end
-- /adeg lines on: the raw tooltip lines of every item that is read are saved (for adding a language),
-- /reload and send the saved variables file. Left and right text of each line, 150 items at most.
function Items.DumpLines(str, lines)
AdeGearDB.lineDump = AdeGearDB.lineDump or {}
local d = AdeGearDB.lineDump
if d[str] or table.getn(lines) == 0 then return end
local count = 0
for _ in pairs(d) do count = count + 1 end
if count >= 150 then return end
local out = {}
for i = 1, table.getn(lines) do
local l, r = lines[i].l or "", lines[i].r
if r then out[i] = l .. " || " .. r else out[i] = l end
end
if GetItemInfo then
local v1, v2, v3, v4, v5, v6, v7, v8, v9 = GetItemInfo(str)
out.info = "name=" .. tostring(v1) .. " | quality=" .. tostring(v3) .. " | minLevel=" .. tostring(v4) .. " | type=" .. tostring(v5)
.. " | subtype=" .. tostring(v6) .. " | stack=" .. tostring(v7) .. " | equipLoc=" .. tostring(v8)
end
d[str] = out
end
-- remember lines we could not read, so the parser can be extended from real items
function Items.LogUnparsed(it)
if not it or table.getn(it.unparsed) == 0 then return end
AdeGearDB = AdeGearDB or {}
AdeGearDB.unparsed = AdeGearDB.unparsed or {}
local count = 0
for _ in pairs(AdeGearDB.unparsed) do count = count + 1 end
for i = 1, table.getn(it.unparsed) do
local line = it.unparsed[i]
-- profession requirements of recipes are not gear lines
if not AdeGearDB.unparsed[line] and count < 400 and not string.find(line, "^Requires ") then
AdeGearDB.unparsed[line] = it.name
count = count + 1
end
end
end
----------------------------------------------------------------------
-- Text for the panel and the chat
----------------------------------------------------------------------
local LABEL = {
WEAPON_RANGED = "Ranged weapon dps", WEAPON_MELEE = "Weapon dps", AMMO_DPS = "Ammo dps",
STR = "Strength", AGI = "Agility", STA = "Stamina", INT = "Intellect", SPI = "Spirit", ARMOR = "Armor",
AP = "Attack power", RAP = "Ranged attack power", SP = "Spell power (all)", HEAL = "Healing power",
FERAL_AP = "Attack power (druid forms)", CASTREGEN = "Mana regen while casting %", HASTE_ATTACK = "Attack speed %", HASTE_CAST = "Casting speed %", ARMORPEN = "Armor penetration", LIFESTEAL = "Damage returned as healing %", WEAPON_WAND = "Wand dps", WEAPON_HIT = "Average hit", SPELLCRIT = "Spell crit %", SPELLHIT = "Spell hit %", CRIT = "Crit %", HIT = "Hit %",
MP5 = "Mana per 5 sec", HP5 = "Health per 5 sec", DODGE = "Dodge %", PARRY = "Parry %",
BLOCK = "Block chance %", BLOCKVAL = "Block value", THORNS = "Damage to attackers", PROC_DMG = "Chance on hit damage", DEFENSE = "Defense", MANA = "Mana", HEALTH = "Health",
}
function Items.Label(key)
if LABEL[key] then return LABEL[key] end
local s, e, rest = string.find(key, "^RES_(.+)$")
if s then return string.upper(string.sub(rest, 1, 1)) .. string.lower(string.sub(rest, 2)) .. " resistance" end
s, e, rest = string.find(key, "^DMG_(.+)$")
if s then return string.upper(string.sub(rest, 1, 1)) .. string.lower(string.sub(rest, 2)) .. " spell power" end
s, e, rest = string.find(key, "^SKILL_(.+)$")
if s then
rest = string.gsub(rest, "_", " ")
return string.upper(string.sub(rest, 1, 1)) .. string.lower(string.sub(rest, 2)) .. " skill"
end
return key
end
local ORDER = { "WEAPON_RANGED", "WEAPON_WAND", "WEAPON_MELEE", "WEAPON_HIT", "AMMO_DPS", "ARMOR", "STR", "AGI", "STA", "INT", "SPI", "AP", "RAP", "SP", "HEAL", "CRIT", "HIT", "SPELLCRIT", "SPELLHIT", "HASTE_ATTACK", "HASTE_CAST", "ARMORPEN", "LIFESTEAL", "MP5", "CASTREGEN", "HP5" }
-- stat keys in a stable, readable order
function Items.SortedKeys(stats)
local keys, seen = {}, {}
for i = 1, table.getn(ORDER) do
if stats[ORDER[i]] then table.insert(keys, ORDER[i]); seen[ORDER[i]] = true end
end
local rest = {}
for k in pairs(stats) do
if not seen[k] then table.insert(rest, k) end
end
table.sort(rest)
for i = 1, table.getn(rest) do table.insert(keys, rest[i]) end
return keys
end
function Items.NumText(v)
if v == math.floor(v) then return string.format("%d", v) end
return string.format("%.1f", v)
end