From 0504ca6287480e5fef13d61975d1b2415e4f011d Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 21 Jun 2026 20:12:50 +0100 Subject: [PATCH] Route trade item values through runtime queries --- Aetheria.State.Verify/Program.cs | 82 +++++++++ Assets/Scripts/UI/Menu/TradeMenu.cs | 75 ++++++-- .../AetheriaRuntimeDaemonTradeItemQueries.cs | 164 ++++++++++++++++++ 3 files changed, 302 insertions(+), 19 deletions(-) create mode 100644 Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonTradeItemQueries.cs diff --git a/Aetheria.State.Verify/Program.cs b/Aetheria.State.Verify/Program.cs index 025d4e883..e4e44e654 100644 --- a/Aetheria.State.Verify/Program.cs +++ b/Aetheria.State.Verify/Program.cs @@ -49,6 +49,7 @@ RequireInventoryEquippedItemDetailsUseEveSurface(root); RequireTradeCargoSelectorUseEveSurface(root); RequireTradeFilterAndRowActionsUseEveSurface(root); RequireTradeItemDetailsUseEveSurface(root); +RequireTradeItemValuesUseRuntimeQueries(root); RequireInventoryDropdownUseEveSurface(root); RequireNoDeadPopupShells(root); RequirePlayerSettingsEveSurface(root); @@ -4777,6 +4778,87 @@ static void RequireTradeItemDetailsUseEveSurface(string root) } } +static void RequireTradeItemValuesUseRuntimeQueries(string root) +{ + var tradeMenuPath = Path.Combine(root, "Assets", "Scripts", "UI", "Menu", "TradeMenu.cs"); + var tradeQueriesPath = Path.Combine( + root, + "Packages", + "org.gamecult.aetheria.state", + "Runtime", + "AetheriaRuntimeDaemonTradeItemQueries.cs"); + if (!File.Exists(tradeMenuPath)) + { + throw new InvalidOperationException("Cannot verify trade item value projection; TradeMenu.cs is missing."); + } + if (!File.Exists(tradeQueriesPath)) + { + throw new InvalidOperationException("Cannot verify trade item value projection; shared runtime trade item queries are missing."); + } + + var tradeMenu = File.ReadAllText(tradeMenuPath); + var tradeQueries = File.ReadAllText(tradeQueriesPath); + var requiredTradeMenuSymbols = new[] + { + "ProjectTradeItem(item)", + "ProjectTradeItemCommit(", + "ProjectTradeValueSettings(", + "AetheriaRuntimeDaemonTradeItemQueries.ProjectTradeItem(", + "AetheriaRuntimeTradeItemProjection TradeProjection", + "public int Price => TradeProjection.Price", + "public string TierColorHex => TradeProjection.TierColorHex" + }; + var missingTradeMenuSymbols = requiredTradeMenuSymbols + .Where(symbol => !tradeMenu.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (missingTradeMenuSymbols.Length > 0) + { + throw new InvalidOperationException( + "TradeMenu no longer projects trade item price/tier values through shared daemon runtime queries: " + + string.Join(", ", missingTradeMenuSymbols)); + } + + var forbiddenTradeMenuSymbols = new[] + { + "GameManager.ItemManager.GetTier", + "GameManager.ItemManager.GameplaySettings.QualityPriceModifier", + "_itemManager.GameplaySettings.QualityPriceModifier", + "private readonly ItemManager _itemManager", + "new TradeRow(item, FindTypedTradeItem(item), GameManager.ItemManager)" + }; + var tradeMenuHits = forbiddenTradeMenuSymbols + .Where(symbol => tradeMenu.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (tradeMenuHits.Length > 0) + { + throw new InvalidOperationException( + "TradeMenu still asks Unity ItemManager for trade item value projection: " + + string.Join(", ", tradeMenuHits)); + } + + var requiredQuerySymbols = new[] + { + "public static class AetheriaRuntimeDaemonTradeItemQueries", + "public readonly struct AetheriaRuntimeTradeItemProjection", + "public sealed class AetheriaRuntimeTradeValueSettings", + "public readonly struct AetheriaRuntimeItemRarityTier", + "public readonly struct AetheriaRuntimeExponentialLerp", + "public static AetheriaRuntimeTradeItemProjection ProjectTradeItem(", + "settings.QualityPriceModifier.Evaluate(quality.Value) * typedItem.Price", + "SelectTier(settings.Tiers, quality.Value)", + "AetheriaRuntimeDaemonItemStatQueries.ItemCommit(" + }; + var missingQuerySymbols = requiredQuerySymbols + .Where(symbol => !tradeQueries.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (missingQuerySymbols.Length > 0) + { + throw new InvalidOperationException( + "Shared runtime trade item queries no longer own price/tier projection: " + + string.Join(", ", missingQuerySymbols)); + } +} + static void RequireInventoryDropdownUseEveSurface(string root) { var inventoryPanelPath = Path.Combine(root, "Assets", "Scripts", "UI", "Menu", "InventoryPanel.cs"); diff --git a/Assets/Scripts/UI/Menu/TradeMenu.cs b/Assets/Scripts/UI/Menu/TradeMenu.cs index 2da01fe5e..739efaba5 100644 --- a/Assets/Scripts/UI/Menu/TradeMenu.cs +++ b/Assets/Scripts/UI/Menu/TradeMenu.cs @@ -82,8 +82,8 @@ public class TradeMenu : MonoBehaviour var columns = new List<(string name, int size, Func> output, Func sortKey)>(); columns.Add(("Name", 3, - x => () => x.Item is CraftedItemInstance craftedItemInstance ? - $"{x.Name}" : + x => () => x.Item is CraftedItemInstance && !string.IsNullOrWhiteSpace(x.TierColorHex) ? + $"{x.Name}" : x.Name, x => x.Name)); if(_hardpointFilter.filter==null) @@ -120,7 +120,7 @@ public class TradeMenu : MonoBehaviour var items = Inventory.Cargo.Keys .Where(PassesTypedTradeFilters) - .Select(item => new TradeRow(item, FindTypedTradeItem(item), GameManager.ItemManager)); + .Select(item => new TradeRow(item, FindTypedTradeItem(item), ProjectTradeItem(item))); if (MinimumSizeFilter.gameObject.activeSelf) items = items.Where(i => @@ -279,6 +279,46 @@ public class TradeMenu : MonoBehaviour return ActionGameManager.RuntimeCatalog?.FindItem(item?.ItemKey ?? ""); } + private static AetheriaRuntimeTradeItemProjection ProjectTradeItem(ItemInstance item) + { + var typedItem = FindTypedTradeItem(item); + return AetheriaRuntimeDaemonTradeItemQueries.ProjectTradeItem( + typedItem, + ProjectTradeItemCommit(item), + ProjectTradeValueSettings()); + } + + private static AetheriaRuntimeLoadoutItemCommit? ProjectTradeItemCommit(ItemInstance item) + { + if (item is not CraftedItemInstance crafted) + return null; + + var durability = item is EquippableItem equippable ? equippable.Durability : 1f; + return AetheriaRuntimeDaemonTradeItemQueries.CraftedItemCommit( + item.ItemKey, + crafted.Quality, + durability); + } + + private static AetheriaRuntimeTradeValueSettings ProjectTradeValueSettings() + { + var source = ActionGameManager.Settings.GameplaySettings; + var priceModifier = source.QualityPriceModifier; + return new AetheriaRuntimeTradeValueSettings( + new AetheriaRuntimeExponentialLerp( + priceModifier.Exponent, + priceModifier.Minimum, + priceModifier.Maximum), + (source.Tiers ?? Array.Empty()) + .Select(tier => new AetheriaRuntimeItemRarityTier( + tier.Name, + tier.Quality, + tier.Color.x, + tier.Color.y, + tier.Color.z)) + .ToArray()); + } + private static double GetTypedBehaviorNumber(TradeRow row, BehaviorFilter behaviorFilter, AetheriaRuntimeBehaviorFieldMetadata field) { var payload = FindTypedBehaviorPayload(row.TypedItem, behaviorFilter); @@ -333,37 +373,31 @@ public class TradeMenu : MonoBehaviour private sealed class TradeRow { - private readonly ItemManager _itemManager; - - public TradeRow(ItemInstance item, AetheriaRuntimeCatalogItem typedItem, ItemManager itemManager) + public TradeRow( + ItemInstance item, + AetheriaRuntimeCatalogItem typedItem, + AetheriaRuntimeTradeItemProjection tradeProjection) { Item = item; TypedItem = typedItem; - _itemManager = itemManager; + TradeProjection = tradeProjection; } public ItemInstance Item { get; } public AetheriaRuntimeCatalogItem TypedItem { get; } + public AetheriaRuntimeTradeItemProjection TradeProjection { get; } + public string ItemKey => Item?.ItemKey ?? ""; public string Name => !string.IsNullOrWhiteSpace(TypedItem?.Name) ? TypedItem.Name : "Unknown Item"; public float Mass => TypedItem != null ? (float)TypedItem.Mass : 0f; - public int Price - { - get - { - if (Item is CraftedItemInstance craftedItemInstance) - return TypedItem != null - ? (int)(_itemManager.GameplaySettings.QualityPriceModifier.Evaluate(craftedItemInstance.Quality) * TypedItem.Price) - : 0; + public int Price => TradeProjection.Price; - return TypedItem != null ? TypedItem.Price : 0; - } - } + public string TierColorHex => TradeProjection.TierColorHex; public int ShapeWidth => TypedItem != null && TypedItem.ShapeWidth > 0 ? TypedItem.ShapeWidth : 0; @@ -439,7 +473,10 @@ public class TradeMenu : MonoBehaviour private int GetTypedTradePrice(CraftedItemInstance item, AetheriaRuntimeCatalogItem typedItem) { - return (int)(GameManager.ItemManager.GameplaySettings.QualityPriceModifier.Evaluate(item.Quality) * typedItem.Price); + return AetheriaRuntimeDaemonTradeItemQueries.ProjectTradeItem( + typedItem, + ProjectTradeItemCommit(item), + ProjectTradeValueSettings()).Price; } private void ShowUnableToBuy(string reason) diff --git a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonTradeItemQueries.cs b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonTradeItemQueries.cs new file mode 100644 index 000000000..f2bede68a --- /dev/null +++ b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonTradeItemQueries.cs @@ -0,0 +1,164 @@ +using System; +using System.Collections.Generic; +using System.Globalization; + +#nullable enable + +namespace GameCult.Aetheria.State.Verse +{ + public readonly struct AetheriaRuntimeExponentialLerp + { + public AetheriaRuntimeExponentialLerp(double exponent, double minimum, double maximum) + { + Exponent = exponent; + Minimum = minimum; + Maximum = maximum; + } + + public double Exponent { get; } + public double Minimum { get; } + public double Maximum { get; } + + public double Evaluate(double value) + { + var t = value < 0 ? 0 : value > 1 ? 1 : value; + return Minimum + Math.Pow(t, Exponent) * (Maximum - Minimum); + } + } + + public readonly struct AetheriaRuntimeItemRarityTier + { + public AetheriaRuntimeItemRarityTier(string name, double quality, double red, double green, double blue) + { + Name = name ?? ""; + Quality = quality; + Red = red; + Green = green; + Blue = blue; + } + + public string Name { get; } + public double Quality { get; } + public double Red { get; } + public double Green { get; } + public double Blue { get; } + } + + public sealed class AetheriaRuntimeTradeValueSettings + { + public AetheriaRuntimeTradeValueSettings( + AetheriaRuntimeExponentialLerp qualityPriceModifier, + IReadOnlyList tiers) + { + QualityPriceModifier = qualityPriceModifier; + Tiers = tiers ?? Array.Empty(); + } + + public AetheriaRuntimeExponentialLerp QualityPriceModifier { get; } + public IReadOnlyList Tiers { get; } + } + + public readonly struct AetheriaRuntimeTradeItemProjection + { + public AetheriaRuntimeTradeItemProjection( + int price, + string tierName, + string tierColorHex, + int upgrades) + { + Price = price; + TierName = tierName ?? ""; + TierColorHex = tierColorHex ?? ""; + Upgrades = upgrades; + } + + public int Price { get; } + public string TierName { get; } + public string TierColorHex { get; } + public int Upgrades { get; } + public bool HasTier => !string.IsNullOrWhiteSpace(TierName); + } + + public static class AetheriaRuntimeDaemonTradeItemQueries + { + public static AetheriaRuntimeTradeItemProjection ProjectTradeItem( + AetheriaRuntimeCatalogItem? typedItem, + AetheriaRuntimeLoadoutItemCommit? item, + AetheriaRuntimeTradeValueSettings? settings) + { + if (typedItem == null) + return default; + + var quality = item?.Quality; + var price = quality.HasValue && settings != null + ? (int)(settings.QualityPriceModifier.Evaluate(quality.Value) * typedItem.Price) + : typedItem.Price; + + var tier = quality.HasValue && settings != null + ? SelectTier(settings.Tiers, quality.Value) + : null; + var upgrades = tier.HasValue && quality.HasValue + ? Upgrades(tier.Value, quality.Value) + : 0; + + return new AetheriaRuntimeTradeItemProjection( + price, + tier?.Name ?? "", + tier.HasValue ? ToHex(tier.Value) : "", + upgrades); + } + + public static AetheriaRuntimeLoadoutItemCommit CraftedItemCommit( + string itemKey, + double quality, + double durability = 1) + { + return AetheriaRuntimeDaemonItemStatQueries.ItemCommit( + itemKey, + quality, + durability); + } + + private static AetheriaRuntimeItemRarityTier? SelectTier( + IReadOnlyList tiers, + double quality) + { + if (tiers == null || tiers.Count == 0) + return null; + + var tier = tiers[0]; + foreach (var candidate in tiers) + { + if (quality + .001 > candidate.Quality) + tier = candidate; + } + + return tier; + } + + private static int Upgrades(AetheriaRuntimeItemRarityTier tier, double quality) + { + return (int)((quality - tier.Quality) / .0499); + } + + private static string ToHex(AetheriaRuntimeItemRarityTier tier) + { + return $"{ToByte(tier.Red):X2}{ToByte(tier.Green):X2}{ToByte(tier.Blue):X2}"; + } + + private static int ToByte(double value) + { + var scaled = Clamp01(value) * 255; + return int.Parse( + Math.Round(scaled).ToString(CultureInfo.InvariantCulture), + CultureInfo.InvariantCulture); + } + + private static double Clamp01(double value) + { + if (value < 0) + return 0; + return value > 1 ? 1 : value; + } + } +}