Port minion stat sorting options for trade and tree (#9930)

* Apply changes from PathOfBuildingCommunity/PathOfBuilding-PoE2#2261

* Fix merge conflicts

* Rework timeless fallback weights

* Removed dead variable

* Fix calcs and clean up some code

Fixes the implementaiton of lower is better stats and cleans up it's usage
Fixes the unique list not using the minion stat sorting correctly

---------

Co-authored-by: vaisest <vaisest@users.noreply.github.com>
Co-authored-by: LocalIdentity <localidentity2@gmail.com>

Author: vaisest

spec/System/TestItemDBControl_spec.lua

@@ -0,0 +1,54 @@
+describe("ItemDBControl", function()
+	it("sorts lower-is-better stats below zero", function()
+		local function makeItem(name)
+			return {
+				name = name,
+				base = {},
+				enchantModLines = {},
+				implicitModLines = {},
+				explicitModLines = {},
+				baseModList = {},
+			}
+		end
+		local betterItem = makeItem("Better Item")
+		local worseItem = makeItem("Worse Item")
+		local invalidItem = makeItem("Invalid Item")
+		local takenDamage = {
+			[betterItem] = 80,
+			[worseItem] = 120,
+		}
+		local itemsTab = {
+			activeItemSet = { useSecondWeaponSet = false },
+			slots = { ["Body Armour"] = {} },
+			build = {
+				calcsTab = {
+					GetMiscCalculator = function()
+						return function(args)
+							return { PhysicalTakenHit = takenDamage[args.repItem] }
+						end
+					end,
+				},
+			},
+			IsItemValidForSlot = function(_, item)
+				return item ~= invalidItem
+			end,
+		}
+		local control = new("ItemDBControl", nil, { 0, 0, 100, 100 }, itemsTab, {
+			list = { invalidItem, betterItem, worseItem },
+		}, "RARE")
+		control.sortDetail = {
+			stat = "PhysicalTakenHit",
+			transform = function(value) return -value end,
+		}
+		control.sortOrder = { control.sortControl.STAT, control.sortControl.NAME }
+
+		control:ListBuilder()
+
+		assert.are.equal(betterItem, control.list[1])
+		assert.are.equal(worseItem, control.list[2])
+		assert.are.equal(invalidItem, control.list[3])
+		assert.are.equal(-80, betterItem.measuredPower)
+		assert.are.equal(-120, worseItem.measuredPower)
+		assert.are.equal(-math.huge, invalidItem.measuredPower)
+	end)
+end)

spec/System/TestTradeQueryGenerator_spec.lua

@@ -15,6 +15,17 @@ describe("TradeQueryGenerator", function()
 	end)
 
 	describe("WeightedRatioOutputs", function()
+		local maxStatIncrease
+
+		before_each(function()
+			maxStatIncrease = data.misc.maxStatIncrease
+			data.misc.maxStatIncrease = 1000
+		end)
+
+		after_each(function()
+			data.misc.maxStatIncrease = maxStatIncrease
+		end)
+
 		-- Pass: Returns 0, avoiding math errors
 		-- Fail: Returns NaN/inf or crashes, indicating unhandled infinite values, causing evaluation failures in infinite-scaling builds
 		it("handles infinite base", function()
@@ -31,10 +42,63 @@ describe("TradeQueryGenerator", function()
 			local baseOutput = { TotalDPS = 0 }
 			local newOutput = { TotalDPS = 100 }
 			local statWeights = { { stat = "TotalDPS", weightMult = 1 } }
-			data.misc.maxStatIncrease = 1000
 			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
 			assert.are.equal(result, 100)
 		end)
+		it("uses minion output for non-FullDPS stats when minion output is desired", function()
+			local baseOutput = { Life = 10, Minion = { Life = 100 } }
+			local newOutput = { Life = 10, Minion = { Life = 250 } }
+			local statWeights = { { stat = "MinionLife", weightMult = 1 } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+
+			assert.are.equal(result, 2.5)
+		end)
+
+		it("uses lower is better stats correctly", function()
+			local baseOutput = { MaxHit = 100 }
+			local newOutput = { MaxHit = 10 }
+			local statWeights = { { stat = "MaxHit", weightMult = 1, transform = function(number) return -number end } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+
+			local close_enough = math.abs(result - -0.1) < 0.0001
+			assert.True(close_enough)
+		end)
+
+		it("uses player and minion output for FullDPS", function()
+			-- minion output gets assigned to the player's full dps in reality
+			local baseOutput = { FullDPS = 100, Minion = { FullDPS = 100 } }
+			local newOutput = { FullDPS = 250, Minion = { FullDPS = 1000 } }
+			local statWeights = { { stat = "FullDPS", weightMult = 1 } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+
+			assert.are.equal(result, 2.5)
+		end)
+
+		it("uses player output for non-FullDPS even when minion output is available", function()
+			local baseOutput = { Life = 100, Minion = { Life = 100 } }
+			local newOutput = { Life = 250, Minion = { Life = 1000 } }
+			local statWeights = { { stat = "Life", weightMult = 1 } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+			assert.are.equal(result, 2.5)
+		end)
+
+		it("uses the fallback DPS ratio once when FullDPS is unavailable", function()
+			local baseOutput = { Minion = { TotalDPS = 10, TotalDotDPS = 0, CombinedDPS = 10 } }
+			local newOutput = { Minion = { TotalDPS = 25, TotalDotDPS = 0, CombinedDPS = 25 } }
+			local statWeights = { { stat = "FullDPS", weightMult = 1 } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+
+			assert.are.equal(result, 2.5)
+		end)
+
+		it("falls back to player output when the selected stat is not on minion output", function()
+			local baseOutput = { Spirit = 100, Minion = { AverageDamage = 100 } }
+			local newOutput = { Spirit = 120, Minion = { AverageDamage = 100 } }
+			local statWeights = { { stat = "Spirit", weightMult = 1 } }
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, newOutput, statWeights)
+
+			assert.are.equal(result, 1.2)
+		end)
 	end)
 
 	describe("Filter prioritization", function()

spec/System/TestTradeQuery_spec.lua

@@ -1,4 +1,11 @@
 describe("TradeQuery", function()
+	local mock_tradeQuery
+	local mock_queryGen
+
+	before_each(function()
+		mock_tradeQuery = new("TradeQuery", { itemsTab = {} })
+		mock_queryGen = new("TradeQueryGenerator", { itemsTab = {} })
+	end)
 	describe("result dropdown tooltipFunc", function()
 		-- Builds a TradeQuery with the strict minimum needed for
 		-- PriceItemRowDisplay to construct row 1 without exploding. Only the
@@ -54,4 +61,57 @@ describe("TradeQuery", function()
 			assert.are.equal(0, #tooltip.lines)
 		end)
 	end)
+	describe("ReduceOutput", function()
+		it("preserves lower-is-better values for weighted result comparison", function()
+			local weights = {
+				{ stat = "PhysicalTakenHit", weightMult = 1, transform = function(value) return -value end },
+			}
+			mock_tradeQuery.statSortSelectionList = weights
+
+			local baseOutput = { PhysicalTakenHit = 100 }
+			local betterOutput = mock_tradeQuery:ReduceOutput({ PhysicalTakenHit = 80 })
+			local worseOutput = mock_tradeQuery:ReduceOutput({ PhysicalTakenHit = 120 })
+			local betterWeight = mock_queryGen.WeightedRatioOutputs(baseOutput, betterOutput, weights)
+			local worseWeight = mock_queryGen.WeightedRatioOutputs(baseOutput, worseOutput, weights)
+
+			assert.are.equal(80, betterOutput.PhysicalTakenHit)
+			assert.is_true(betterWeight > worseWeight)
+		end)
+
+		it("uses selected minion stats for weighted result comparison", function()
+			mock_tradeQuery.statSortSelectionList = { { stat = "AverageDamage" } }
+
+			local result = mock_tradeQuery:ReduceOutput({
+				AverageDamage = 10,
+				Life = 100,
+				Minion = {
+					AverageDamage = 250,
+					Life = 200,
+				},
+			})
+
+			assert.are.equals(260, result.AverageDamage)
+			assert.is_nil(result.Life)
+		end)
+
+		it("keeps fallback DPS stats when FullDPS is selected but not present", function()
+			mock_tradeQuery.statSortSelectionList = { { stat = "FullDPS", weightMult = 1 } }
+
+			local baseOutput = {
+				CombinedDPS = 100,
+				TotalDPS = 100,
+				TotalDotDPS = 0,
+			}
+			local reducedOutput = mock_tradeQuery:ReduceOutput({
+				CombinedDPS = 120,
+				TotalDPS = 120,
+				TotalDotDPS = 0,
+			})
+
+			local result = mock_queryGen.WeightedRatioOutputs(baseOutput, reducedOutput,
+				mock_tradeQuery.statSortSelectionList)
+
+			assert.are.equals(1.2, result)
+		end)
+	end)
 end)

src/Classes/CalcsTab.lua

@@ -712,16 +712,8 @@ function CalcsTabClass:PowerBuilder()
 end
 
 function CalcsTabClass:CalculatePowerStat(selection, original, modified)
-	if modified.Minion and selection.stat ~= "FullDPS" then
-		original = original.Minion
-		modified = modified.Minion
-	end
-	local originalValue = original[selection.stat] or 0
-	local modifiedValue = modified[selection.stat] or 0
-	if selection.transform then
-		originalValue = selection.transform(originalValue)
-		modifiedValue = selection.transform(modifiedValue)
-	end
+	local originalValue = data.powerStatList.GetFromOutput(original, selection)
+	local modifiedValue = data.powerStatList.GetFromOutput(modified, selection)
 	return originalValue - modifiedValue
 end
 
@@ -732,10 +724,9 @@ function CalcsTabClass:CalculateCombinedOffDefStat(original, modified)
 					(original.Evasion - modified.Evasion) / m_max(10000, modified.Evasion) +
 					(original.LifeRegenRecovery - modified.LifeRegenRecovery) / 500 +
 					(original.EnergyShieldRegenRecovery - modified.EnergyShieldRegenRecovery) / 1000
-	if modified.Minion then
-		return (original.Minion.CombinedDPS - modified.Minion.CombinedDPS) / modified.Minion.CombinedDPS, defence
-	end
-	return (original.CombinedDPS - modified.CombinedDPS) / modified.CombinedDPS, defence
+	local modifiedDps = modified.CombinedDPS + (modified.Minion and modified.Minion.CombinedDPS or 0)
+	local dpsIncr = original.CombinedDPS + (original.Minion and original.Minion.CombinedDPS or 0) - modifiedDps
+	return dpsIncr / modifiedDps, defence
 end
 
 function CalcsTabClass:GetNodeCalculator()

src/Classes/CompareTab.lua

@@ -2577,10 +2577,7 @@ function CompareTabClass:ComparePowerBuilder(compareEntry, powerStat, categories
 	end
 
 	-- Get baseline stat value for percentage calculation
-	local baseStatValue = calcBase[powerStat.stat] or 0
-	if powerStat.transform then
-		baseStatValue = powerStat.transform(baseStatValue)
-	end
+	local baseStatValue = data.powerStatList.GetFromOutput(calcBase, powerStat)
 
 	-- Helper to format an impact value and compute percentage
 	local function formatImpact(impact)

src/Classes/ItemDBControl.lua

@@ -190,7 +190,7 @@ end
 
 function ItemDBClass:BuildSortOrder()
 	wipeTable(self.sortDropList)
-	for id,stat in pairs(data.powerStatList) do
+	for id, stat in ipairs(data.powerStatList) do
 		if not stat.ignoreForItems then
 			t_insert(self.sortDropList, {
 				label="Sort by "..stat.label,
@@ -227,14 +227,11 @@ function ItemDBClass:ListBuilder()
 		local start = GetTime()
 		local calcFunc, calcBase = self.itemsTab.build.calcsTab:GetMiscCalculator(self.build)
 		for itemIndex, item in ipairs(list) do
-			item.measuredPower = 0
+			item.measuredPower = -math.huge
 			for slotName, slot in pairs(self.itemsTab.slots) do
 				if self.itemsTab:IsItemValidForSlot(item, slotName) and not slot.inactive and (not slot.weaponSet or slot.weaponSet == (self.itemsTab.activeItemSet.useSecondWeaponSet and 2 or 1)) then
 					local output = calcFunc(item.base.flask and { toggleFlask = item } or item.base.tincture and { toggleTincture = item } or { repSlotName = slotName, repItem = item }, useFullDPS)
-					local measuredPower = output.Minion and output.Minion[self.sortMode] or output[self.sortMode] or 0
-					if self.sortDetail.transform then
-						measuredPower = self.sortDetail.transform(measuredPower)
-					end
+					local measuredPower = data.powerStatList.GetFromOutput(output, self.sortDetail)
 					item.measuredPower = m_max(item.measuredPower, measuredPower)
 				end
 			end
@@ -363,4 +360,4 @@ function ItemDBClass:OnHoverKeyUp(key)
 			itemLib.wiki.openItem(item)
 		end
 	end
-end
+end