Fix level requirements on staves, wands, and jewellery and unique items (#2323)

* Remove item requirements from granted skills

* Initial commit, level reqs fixed

* Fix unique exports

The unique export now has a number of fixes and additions
It now inherits the implicit mods from a item base and include skill mods in the implicit count without having to specifically state it
It correctly orders implicit mods now which was not done before
Bases that grant skills now use the correct level range
e.g Raise Shield now doesn't show the level range of 1-20
Belt bases now have the correct implicit mods and exclude the charm mod if the base already grants it
Level requirements for gear now only print the value if it exceeds the base type
Many uniques have had their unique mod IDs updated to use the correct ones so the required level is correct

* Import + some base fixes

Uniques not grab their base level from the unique in the db so that if they are modified by runes they can fall back to the correct level if the rune is removed
Fixed the level requirement for Runic Fork as it wasn't being exported as it didn't have a skill
Fix the export of uniques with legacy implicits not having the correct Implicit count
Fix Wondertrap export typo
Clean up uModsToText script
Adds tests for new scenarios

* ModCache

* Spelling

* Fix test to use correct base type

---------

Co-authored-by: LocalIdentity <localidentity2@gmail.com>

Author: Blitz54

spec/System/TestImportReimport_spec.lua

@@ -220,6 +220,67 @@ Fireball 20/0  1
 		assert.are.equal(0, build.itemsTab.slots["Gloves Jewel Socket 2"].selItemId)
 	end)
 
+	it("uses unique database and rune levels when importing unique items from account data", function()
+		while main.uniqueDB.loading do
+			runCallback("OnFrame")
+		end
+
+		build.importTab.controls.charImportItemsClearItems.state = true
+		build.importTab.controls.charImportItemsClearSkills.state = true
+
+		local body = makeImportItem("Rusted Cuirass", "BodyArmour", "test-import-bramblejack")
+		body.frameType = 3
+		body.name = "Bramblejack"
+		body.requirements = {
+			{ name = "Level", values = { { "22", 0 } } },
+		}
+		build.importTab:ImportItemsAndSkills(buildImportPayload({ body }, {}))
+		runCallback("OnFrame")
+
+		local importedItem = build.itemsTab.items[build.itemsTab.slots["Body Armour"].selItemId]
+		assert.are.equal("Bramblejack, Rusted Cuirass", importedItem.name)
+		assert.are.equal(0, importedItem.requirements.level)
+
+		body.sockets = {
+			{ type = "rune" },
+		}
+		body.socketedItems = {
+			{ baseType = "Legacy of Blackbraid" },
+		}
+
+		build.importTab:ImportItemsAndSkills(buildImportPayload({ body }, {}))
+		runCallback("OnFrame")
+
+		importedItem = build.itemsTab.items[build.itemsTab.slots["Body Armour"].selItemId]
+		assert.are.equal(65, importedItem.requirements.level)
+
+		importedItem.runes[1] = "None"
+		importedItem:UpdateRunes()
+		importedItem:BuildAndParseRaw()
+		assert.are.equal(0, importedItem.requirements.level)
+
+		local weapon = makeImportItem("Runemastered Ironhead Spear", "Weapon", "test-import-tyranny's-grip")
+		weapon.frameType = 3
+		weapon.name = "Tyranny's Grip"
+		weapon.sockets = {
+			{ type = "rune" },
+		}
+		weapon.socketedItems = {
+			{ baseType = "Legacy of Tyranny's Grip" },
+		}
+
+		build.importTab:ImportItemsAndSkills(buildImportPayload({ weapon }, {}))
+		runCallback("OnFrame")
+
+		importedItem = build.itemsTab.items[build.itemsTab.slots["Weapon 1"].selItemId]
+		assert.are.equal(65, importedItem.requirements.level)
+
+		importedItem.runes[1] = "None"
+		importedItem:UpdateRunes()
+		importedItem:BuildAndParseRaw()
+		assert.are.equal(55, importedItem.requirements.level)
+	end)
+
 	it("preserves skill part selection when reimporting items and skills", function()
 		assertReimportPreservesSkillSubstate("Twig Focus", "Offhand", "Dark Effigy", "skillPart", 2)
 	end)

spec/System/TestItemParse_spec.lua

@@ -375,13 +375,108 @@ describe("TestItemParse", function()
 		assert.are.equals("~price 1 chaos", item.note)
 	end)
 
-	it("Attribute Requirements", function()
-		local item = new("Item", raw("Dex: 100"))
-		assert.are.equals(100, item.requirements.dex)
-		item = new("Item", raw("Int: 101"))
-		assert.are.equals(101, item.requirements.int)
-		item = new("Item", raw("Str: 102"))
-		assert.are.equals(102, item.requirements.str)
+	it("Rune level requirements", function()
+		local item = new("Item", [[
+			Test Wand
+			Runic Fork
+			Sockets: S
+			Rune: Perfect Storm Rune
+			LevelReq: 1
+			Implicits: 1
+			{enchant}{rune}Gain 12% of Damage as Extra Lightning Damage
+		]])
+		assert.are.equals(50, item.requirements.level)
+	end)
+
+	it("Unique mod level requirements", function()
+		local foundAnvil
+		for _, rawUnique in ipairs(data.uniques.amulet) do
+			if rawUnique:match("The Anvil") then
+				local item = new("Item", rawUnique)
+				assert.are.equals(18, item.requirements.level)
+				assert.is_nil(rawUnique:match("Requires Level 18"))
+				foundAnvil = true
+				break
+			end
+		end
+		assert(foundAnvil, "The Anvil not found")
+
+		local foundChoirOfTheStorm
+		for _, rawUnique in ipairs(data.uniques.amulet) do
+			if rawUnique:match("Choir of the Storm") then
+				assert(rawUnique:find("Grants Skill: Level (1-20) Lightning Bolt", 1, true))
+				assert(rawUnique:find("Trigger Lightning Bolt Skill on Critical Hit", 1, true))
+				foundChoirOfTheStorm = true
+				break
+			end
+		end
+		assert(foundChoirOfTheStorm, "Choir of the Storm not found")
+
+		local foundSylvansEffigy
+		for _, rawUnique in ipairs(data.uniques.sceptre) do
+			if rawUnique:match("Sylvan's Effigy") then
+				local item = new("Item", rawUnique)
+				assert.are.equals(62, item.requirements.level)
+				foundSylvansEffigy = true
+				break
+			end
+		end
+		assert(foundSylvansEffigy, "Sylvan's Effigy not found")
+
+		for _, rawUnique in ipairs(data.uniques.amulet) do
+			if rawUnique:match("Hinekora's Sight") then
+				local item = new("Item", rawUnique)
+				assert.are.equals(44, item.requirements.level)
+				assert(rawUnique:find("Grants Skill: Level (1-20) Future-Past", 1, true))
+				return
+			end
+		end
+		assert(false, "Hinekora's Sight not found")
+	end)
+
+	it("keeps legacy base implicit variants as implicits", function()
+		for _, rawUnique in ipairs(data.uniques.belt) do
+			if rawUnique:match("Goregirdle") then
+				assert(rawUnique:find("Implicits: 3\n{variant:2}+(140-180) to Armour\n{variant:1}+(100-140) to Armour\nHas (1-3) Charm Slot", 1, true))
+				return
+			end
+		end
+		assert(false, "Goregirdle not found")
+	end)
+
+	it("uses upgraded base requirements for uniques", function()
+		local item = new("Item", [[
+			Item Class: Spears
+			Rarity: Unique
+			Tyranny's Grip
+			Runemastered Ironhead Spear
+			Requires: Level 55, 31 Str, 76 Dex
+			Item Level: 30
+		]])
+		assert.are.equals(55, item.requirements.level)
+
+		item.itemSocketCount = 1
+		item.runes = { "Legacy of Tyranny's Grip" }
+		item:UpdateRunes()
+		item:BuildAndParseRaw()
+		assert.are.equals(65, item.requirements.level)
+
+		item.runes[1] = "None"
+		item:UpdateRunes()
+		item:BuildAndParseRaw()
+		assert.are.equals(55, item.requirements.level)
+	end)
+
+	it("inherits implicits from variant base types", function()
+		for _, rawUnique in ipairs(data.uniques.shield) do
+			if rawUnique:match("The Surrender") then
+				assert(rawUnique:find("Implicits: 1\nGrants Skill: Raise Shield", 1, true))
+				local item = new("Item", rawUnique)
+				assert.are.equals(75, item.requirements.level)
+				return
+			end
+		end
+		assert(false, "The Surrender not found")
 	end)
 
 	it("Requires Class", function()
@@ -711,6 +806,7 @@ describe("TestItemParse", function()
 			--------
 			Corrupted
 		]])
+		assert.are.equals(90, item.requirements.level)
 
 		local damageGainAsLightning = 0
 		for _, mod in ipairs(item.slotModList[1]) do
@@ -721,6 +817,7 @@ describe("TestItemParse", function()
 		assert.are.equals(120, damageGainAsLightning)
 
 		item:BuildAndParseRaw()
+		assert.are.equals(90, item.requirements.level)
 
 		assert.are.equals(5, item.itemSocketCount)
 		assert.are.equals(5, #item.runes)
@@ -739,6 +836,13 @@ describe("TestItemParse", function()
 		assert.is_not_nil(rawItem:match("{enchant}{rune}Gain 120%% of Damage as Extra Lightning Damage"))
 		assert.is_not_nil(rawItem:match("{enchant}{rune}Remnants you create have 75%% reduced effect"))
 		assert.is_not_nil(rawItem:match("{enchant}{rune}Remnants can be collected from 150%% further away"))
+
+		for i = 1, item.itemSocketCount do
+			item.runes[i] = "None"
+		end
+		item:UpdateRunes()
+		item:BuildAndParseRaw()
+		assert.are.equals(65, item.requirements.level)
 	end)
 
 	it("multi-line rune mod", function()

src/Classes/ImportTab.lua

@@ -48,7 +48,7 @@ local ImportTabClass = newClass("ImportTab", "ControlHost", "Control", function(
 	self.controls.logoutApiButton.shown = function()
 		return (self.charImportMode == "SELECTCHAR" or self.charImportMode == "GETACCOUNTNAME") and main.api.authToken ~= nil
 	end
-	
+
 	self.controls.characterImportAnchor = new("Control", {"TOPLEFT",self.controls.sectionCharImport,"TOPLEFT"}, {6, 40, 200, 16})
 	self.controls.sectionCharImport.height = function() return self.charImportMode == "AUTHENTICATION" and 60 or 200 end
 
@@ -442,7 +442,7 @@ function ImportTabClass:DownloadCharacterList()
 			return "Standard"
 		end
 	end
-	
+
 	self.charImportMode = "DOWNLOADCHARLIST"
 	self.charImportStatus = "Retrieving character list..."
 	local realm = realmList[self.controls.accountRealm.selIndex]
@@ -954,10 +954,10 @@ function ImportTabClass:ImportItemsAndSkills(charData)
 	local funcGetGemInstance = function(skillData)
 		local typeLine = sanitiseText(skillData.typeLine) .. (skillData.support and " Support" or "")
 		local gemId = self.build.data.gemForBaseName[typeLine:lower()]
-		
+
 		if typeLine:match("^Spectre:") then
 			gemId = "Metadata/Items/Gems/SkillGemSummonSpectre"
-		end		
+		end
 		if typeLine:match("^Companion:") then
 			gemId = "Metadata/Items/Gems/SkillGemSummonBeast"
 		end
@@ -1061,7 +1061,7 @@ function ImportTabClass:ImportItemsAndSkills(charData)
 	end
 	for _, skillData in pairs(charData.skills) do
 		local gemInstance = funcGetGemInstance(skillData)
-		
+
 		if gemInstance then
 			local group = { label = "", enabled = true, gemList = { } }
 			t_insert(group.gemList, gemInstance )
@@ -1302,6 +1302,11 @@ function ImportTabClass:ImportItem(itemData, slotName)
 			end
 		end
 	end
+	local dbItem = item:GetUniqueDBItem()
+	if dbItem then
+		item.requirements = item.requirements or { }
+		item.requirements.level = dbItem.requirements.naturalLevel or dbItem.requirements.level
+	end
 	item.enchantModLines = { }
 	item.runeModLines = { }
 	item.classRequirementModLines = { }