feat: support level-based replacements

Model/IWhen.cs

@@ -29,6 +29,10 @@ public class WhenNodeDeserialiser : INodeDeserializer {
                 value = nestedObjectDeserializer(reader, typeof(WhenQuest));
                 break;
             }
+            case "level": {
+                value = nestedObjectDeserializer(reader, typeof(WhenLevel));
+                break;
+            }
             default: {
                 throw new YamlException($"invalid when: unknown type \"{name.Value}\"");
             }

Model/WhenLevel.cs

@@ -0,0 +1,125 @@
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace TimePasses.Model;
+
+[Serializable]
+public class WhenLevel : IWhen {
+    public uint Level { get; init; }
+    public int CompareResult { get; init; }
+    public string Text { get; init; }
+    public bool Slowly { get; init; }
+
+    public bool IsValid(Plugin plugin) {
+        if (plugin.ClientState.LocalPlayer is not { } player) {
+            return false;
+        }
+
+        var cmp = player.Level.CompareTo(this.Level);
+        return this.CompareResult switch {
+            1 when cmp > 0 => true,
+            0 when cmp == 0 => true,
+            -1 when cmp < 0 => true,
+            _ => false,
+        };
+    }
+}
+
+public class WhenLevelConverter : IYamlTypeConverter {
+    public bool Accepts(Type type) {
+        return type == typeof(WhenLevel);
+    }
+
+    public object? ReadYaml(IParser parser, Type type) {
+        parser.Consume<MappingStart>();
+
+        string? text = null;
+        int? comparerResult = null;
+        uint? level = null;
+        var slowly = false;
+        while (parser.Current is not MappingEnd) {
+            var key = parser.Consume<Scalar>();
+            if (!key.IsKey) {
+                throw new YamlException("expected key");
+            }
+
+            var value = parser.Consume<Scalar>();
+
+            switch (key.Value) {
+                case "greaterThan": {
+                    if (comparerResult != null) {
+                        throw new YamlException("duplicate operations in whenlevel");
+                    }
+
+                    comparerResult = 1;
+                    break;
+                }
+                case "equalTo": {
+                    if (comparerResult != null) {
+                        throw new YamlException("duplicate operations in whenlevel");
+                    }
+
+                    comparerResult = 0;
+                    break;
+                }
+                case "lessThan": {
+                    if (comparerResult != null) {
+                        throw new YamlException("duplicate operations in whenlevel");
+                    }
+
+                    comparerResult = -1;
+                    break;
+                }
+                case "level": {
+                    if (!uint.TryParse(value.Value, out var lvl)) {
+                        throw new YamlException("invalid whenlevel: level was not numeric");
+                    }
+
+                    level = lvl;
+                    break;
+                }
+                case "text": {
+                    text = value.Value;
+                    break;
+                }
+                case "slowly": {
+                    if (!bool.TryParse(value.Value, out slowly)) {
+                        throw new YamlException("invalid whenlevel: slowly was not a boolean");
+                    }
+
+                    break;
+                }
+                default: {
+                    continue;
+                }
+            }
+        }
+
+        parser.Consume<MappingEnd>();
+
+        if (text == null) {
+            throw new YamlException("invalid whenlevel: missing text");
+        }
+
+        if (comparerResult == null) {
+            throw new YamlException("invalid whenlevel: missing operation");
+        }
+
+        if (level == null) {
+            throw new YamlException("invalid whenlevel: missing level");
+        }
+
+        return new WhenLevel {
+            CompareResult = comparerResult.Value,
+            Level = level.Value,
+            Text = text,
+            Slowly = slowly,
+        };
+    }
+
+    public void WriteYaml(IEmitter emitter, object? value, Type type)
+    {
+        throw new NotImplementedException();
+    }
+}

Plugin.cs

@@ -14,10 +14,13 @@ namespace TimePasses;
 
 public class Plugin : IDalamudPlugin {
     [PluginService]
-    private IGameInteropProvider GameInterop { get; init; }
+    internal static IPluginLog Log { get; set; }
 
     [PluginService]
-    internal static IPluginLog Log { get; set; }
+    internal IClientState ClientState { get; init; }
+
+    [PluginService]
+    private IGameInteropProvider GameInterop { get; init; }
 
     private HttpClient Client { get; } = new();
 
@@ -27,6 +30,7 @@ public class Plugin : IDalamudPlugin {
 
     private static IDeserializer Deserializer { get; } = new DeserializerBuilder()
         .WithNamingConvention(UnderscoredNamingConvention.Instance)
+        .WithTypeConverter(new WhenLevelConverter())
         .WithNodeDeserializer(new WhenNodeDeserialiser())
         .IgnoreUnmatchedProperties()
         .Build();

replacements.yaml

@@ -12,6 +12,7 @@ replacements:
           text: |-
             The water here
             is so peaceful.
+
   # Original: Start any trouble, and I'll see you rot in the oubliettes for eternity.
   - id: 291
     when:
@@ -21,3 +22,17 @@ replacements:
           text: |-
             My eyes are peeled
             for trouble.
+
+  # Original: Don't ever turn your back on a beastie, hear?
+  - id: 280
+    when:
+      - level:
+          greaterThan: 30
+          text: |-
+            Try not to get
+            swarmed out there.
+      - level:
+          greaterThan: 50
+          text: |-
+            Bet beasties never
+            give you any trouble.