feat(generator): load decay + upkeep from rustlabs files (6b)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

tests/RustPlusBot.ItemData.Generator.Tests/OfflineRustLabsSourceTests.cs

@@ -0,0 +1,52 @@
+using RustPlusBot.ItemData.Generator.Sources;
+
+namespace RustPlusBot.ItemData.Generator.Tests;
+
+public sealed class OfflineRustLabsSourceTests
+{
+    private static OfflineRustLabsSource SourceWith(string decayJson, string upkeepJson)
+    {
+        var decayPath = Path.GetTempFileName();
+        var upkeepPath = Path.GetTempFileName();
+        File.WriteAllText(decayPath, decayJson);
+        File.WriteAllText(upkeepPath, upkeepJson);
+        // Recycle/craft/research paths are unused by these two loaders; point them at the upkeep temp file.
+        return new OfflineRustLabsSource(upkeepPath, upkeepPath, upkeepPath, decayPath, upkeepPath);
+    }
+
+    [Fact]
+    public void LoadDecay_readsItemsWrapper_andSecondsAndHp()
+    {
+        const string decay =
+            """{"items":{"15388698":{"decay":900,"decayString":"15 min","decayOutside":null,"decayInside":null,"decayUnderwater":null,"hp":100,"hpString":"100"}}}""";
+        var result = SourceWith(decay, """{"items":{}}""").LoadDecay();
+
+        Assert.True(result.ContainsKey(15388698));
+        Assert.Equal(900, result[15388698].Seconds);
+        Assert.Equal(100, result[15388698].Hp);
+        Assert.Null(result[15388698].OutsideSeconds);
+    }
+
+    [Fact]
+    public void LoadUpkeep_readsItemsWrapper_andParsesRange()
+    {
+        const string upkeep =
+            """{"items":{"1729120840":[{"id":"-151838493","quantity":"8–25"}]}}""";
+        var result = SourceWith("""{"items":{}}""", upkeep).LoadUpkeep();
+
+        Assert.True(result.ContainsKey(1729120840));
+        var entry = Assert.Single(result[1729120840].Entries);
+        Assert.Equal(-151838493, entry.ItemId);
+        Assert.Equal(8, entry.QuantityMin);
+        Assert.Equal(25, entry.QuantityMax);
+    }
+
+    [Fact]
+    public void LoadUpkeep_singleQuantity_hasEqualMinMax()
+    {
+        const string upkeep = """{"items":{"671706427":[{"id":"317398316","quantity":"1"}]}}""";
+        var entry = Assert.Single(SourceWith("""{"items":{}}""", upkeep).LoadUpkeep()[671706427].Entries);
+        Assert.Equal(1, entry.QuantityMin);
+        Assert.Equal(1, entry.QuantityMax);
+    }
+}

tools/RustPlusBot.ItemData.Generator/Program.cs

@@ -60,7 +60,9 @@ internal static int Main(string[] args)
         var rustLabsSource = new OfflineRustLabsSource(
             Path.Combine(rustplusDir, "rustlabsRecycleData.json"),
             Path.Combine(rustplusDir, "rustlabsCraftData.json"),
-            Path.Combine(rustplusDir, "rustlabsResearchData.json"));
+            Path.Combine(rustplusDir, "rustlabsResearchData.json"),
+            Path.Combine(rustplusDir, "rustlabsDecayData.json"),
+            Path.Combine(rustplusDir, "rustlabsUpkeepData.json"));
 
         var names = namesSource.LoadNames();
         Console.WriteLine($"Loaded {names.Count} names from items.json");

tools/RustPlusBot.ItemData.Generator/Sources/IRustLabsSource.cs

@@ -13,4 +13,10 @@ internal interface IRustLabsSource
 
     /// <summary>Loads research costs keyed by item id.</summary>
     IReadOnlyDictionary<int, ResearchCost> LoadResearchCosts();
+
+    /// <summary>Loads decay info keyed by item id.</summary>
+    IReadOnlyDictionary<int, DecayInfo> LoadDecay();
+
+    /// <summary>Loads upkeep costs keyed by item id.</summary>
+    IReadOnlyDictionary<int, UpkeepCost> LoadUpkeep();
 }

tools/RustPlusBot.ItemData.Generator/Sources/OfflineRustLabsSource.cs

@@ -4,14 +4,18 @@
 
 namespace RustPlusBot.ItemData.Generator.Sources;
 
-/// <summary>Reads recycle, craft, and research data from the offline RustLabs JSON files.</summary>
+/// <summary>Reads recycle, craft, research, decay, and upkeep data from the offline RustLabs JSON files.</summary>
 /// <param name="RecycleFilePath">Path to the <c>rustlabsRecycleData.json</c> file.</param>
 /// <param name="CraftFilePath">Path to the <c>rustlabsCraftData.json</c> file.</param>
 /// <param name="ResearchFilePath">Path to the <c>rustlabsResearchData.json</c> file.</param>
+/// <param name="DecayFilePath">Path to the <c>rustlabsDecayData.json</c> file.</param>
+/// <param name="UpkeepFilePath">Path to the <c>rustlabsUpkeepData.json</c> file.</param>
 internal sealed class OfflineRustLabsSource(
     string RecycleFilePath,
     string CraftFilePath,
-    string ResearchFilePath) : IRustLabsSource
+    string ResearchFilePath,
+    string DecayFilePath,
+    string UpkeepFilePath) : IRustLabsSource
 {
     private static readonly Dictionary<string, int> WorkbenchLevels = new()
     {
@@ -160,4 +164,83 @@ public IReadOnlyDictionary<int, ResearchCost> LoadResearchCosts()
 
         return result;
     }
+
+    /// <inheritdoc/>
+    public IReadOnlyDictionary<int, DecayInfo> LoadDecay()
+    {
+        using var stream = File.OpenRead(DecayFilePath);
+        using var doc = JsonDocument.Parse(stream);
+
+        var result = new Dictionary<int, DecayInfo>();
+        if (!doc.RootElement.TryGetProperty("items", out var itemsEl))
+        {
+            return result;
+        }
+
+        foreach (var prop in itemsEl.EnumerateObject())
+        {
+            if (!int.TryParse(prop.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id))
+            {
+                continue;
+            }
+
+            result[id] = new DecayInfo(
+                ReadInt(prop.Value, "decay"),
+                ReadInt(prop.Value, "decayOutside"),
+                ReadInt(prop.Value, "decayInside"),
+                ReadInt(prop.Value, "decayUnderwater"),
+                ReadInt(prop.Value, "hp"));
+        }
+
+        return result;
+
+        static int? ReadInt(JsonElement element, string name) =>
+            element.TryGetProperty(name, out var p) && p.ValueKind == JsonValueKind.Number
+                ? p.GetInt32()
+                : null;
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyDictionary<int, UpkeepCost> LoadUpkeep()
+    {
+        using var stream = File.OpenRead(UpkeepFilePath);
+        using var doc = JsonDocument.Parse(stream);
+
+        var result = new Dictionary<int, UpkeepCost>();
+        if (!doc.RootElement.TryGetProperty("items", out var itemsEl))
+        {
+            return result;
+        }
+
+        foreach (var prop in itemsEl.EnumerateObject())
+        {
+            if (!int.TryParse(prop.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id))
+            {
+                continue;
+            }
+
+            var entries = new List<UpkeepEntry>();
+            foreach (var entry in prop.Value.EnumerateArray())
+            {
+                var entryIdStr = entry.GetProperty("id").GetString();
+                if (entryIdStr is null ||
+                    !int.TryParse(entryIdStr, NumberStyles.Integer, CultureInfo.InvariantCulture, out var entryId))
+                {
+                    continue;
+                }
+
+                var quantity = entry.GetProperty("quantity").GetString()
+                               ?? throw new InvalidOperationException($"upkeep {id}: null quantity");
+                var (min, max) = UpkeepQuantity.Parse(quantity);
+                entries.Add(new UpkeepEntry(entryId, min, max));
+            }
+
+            if (entries.Count > 0)
+            {
+                result[id] = new UpkeepCost(entries);
+            }
+        }
+
+        return result;
+    }
 }