feat,refactor(replacements): add a global replacement registry

Allows for global replacements to be registered on the map level: ```xml <replacements> <switch id="bombsite"> <case filter="filter-a" result="filter-a-result"/> <case filter="filter-b" result="filter-b-result"/> </switch> </replacements> ``` Where required, a global replacement requires a matching scope (in actions, the scope is inherited from the current scope): ```xml <replacements> <switch value="variable" scope="match"> ... <fallback>...</fallback> </switch> </replacements> ``` A globally defined replacement then can be referred to from within as: ```xml  <replacements> <player id="global-replacement" var="variable" fallback="an unknown player"/> </replacements>  <message text="... {replacement}"> <replacements> <replacement id="replacement">global-replacement</replacement> </replacements> </message> ``` To support for this, replacement parsing has been forked out of ActionParser. Signed-off-by: TTtie <[email protected]>
PGMDev · Dec 16, 2024 · e8cd0a1 · e8cd0a1
1 parent 752fbcd
commit e8cd0a1
Show file tree

Hide file tree

Showing 8 changed files with 358 additions and 86 deletions.
diff --git a/core/src/main/java/tc/oc/pgm/action/ActionModule.java b/core/src/main/java/tc/oc/pgm/action/ActionModule.java
@@ -8,6 +8,7 @@
 import org.jdom2.Element;
 import org.jetbrains.annotations.Nullable;
 import tc.oc.pgm.action.actions.ExposedAction;
+import tc.oc.pgm.action.replacements.ReplacementParser;
 import tc.oc.pgm.api.map.MapModule;
 import tc.oc.pgm.api.map.factory.MapFactory;
 import tc.oc.pgm.api.map.factory.MapModuleFactory;
@@ -58,6 +59,12 @@ public Collection<Class<? extends MapModule<?>>> getWeakDependencies() {
     public ActionModule parse(MapFactory factory, Logger logger, Document doc)
         throws InvalidXMLException {
       ActionParser parser = factory.getParser().getActionParser();
+      var replacementParser = new ReplacementParser(factory, true);
+
+      for (var replacement : XMLUtils.flattenElements(
+          doc.getRootElement(), Set.of("replacements"), replacementParser.replacementTypes())) {
+        replacementParser.parse(replacement, null);
+      }
 
       for (Element action :
           XMLUtils.flattenElements(doc.getRootElement(), Set.of("actions"), parser.actionTypes())) {

diff --git a/core/src/main/java/tc/oc/pgm/action/ActionParser.java b/core/src/main/java/tc/oc/pgm/action/ActionParser.java
@@ -3,16 +3,11 @@
 import static net.kyori.adventure.key.Key.key;
 import static net.kyori.adventure.sound.Sound.sound;
 import static net.kyori.adventure.text.Component.empty;
-import static net.kyori.adventure.text.Component.text;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import java.lang.reflect.Method;
-import java.text.DecimalFormat;
-import java.text.NumberFormat;
-import java.util.ArrayList;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import net.kyori.adventure.sound.Sound;
@@ -37,6 +32,8 @@
 import tc.oc.pgm.action.actions.TakePaymentAction;
 import tc.oc.pgm.action.actions.TeleportAction;
 import tc.oc.pgm.action.actions.VelocityAction;
+import tc.oc.pgm.action.replacements.Replacement;
+import tc.oc.pgm.action.replacements.ReplacementParser;
 import tc.oc.pgm.api.feature.FeatureValidation;
 import tc.oc.pgm.api.filter.Filter;
 import tc.oc.pgm.api.filter.Filterables;
@@ -59,7 +56,6 @@
 import tc.oc.pgm.util.MethodParsers;
 import tc.oc.pgm.util.inventory.ItemMatcher;
 import tc.oc.pgm.util.math.Formula;
-import tc.oc.pgm.util.named.NameStyle;
 import tc.oc.pgm.util.xml.InvalidXMLException;
 import tc.oc.pgm.util.xml.Node;
 import tc.oc.pgm.util.xml.XMLFluentParser;
@@ -68,20 +64,20 @@
 
 public class ActionParser {
 
-  private static final NumberFormat DEFAULT_FORMAT = NumberFormat.getIntegerInstance();
-
   private final MapFactory factory;
   private final boolean legacy;
   private final FeatureDefinitionContext features;
   private final XMLFluentParser parser;
   private final Map<String, Method> methodParsers;
+  private final ReplacementParser replacementParser;
 
   public ActionParser(MapFactory factory) {
     this.factory = factory;
     this.legacy = !factory.getProto().isNoOlderThan(MapProtos.ACTION_REVAMP);
     this.features = factory.getFeatures();
     this.parser = factory.getParser();
     this.methodParsers = MethodParsers.getMethodParsersForClass(getClass());
+    replacementParser = new ReplacementParser(factory);
   }
 
   public <B extends Filterable<?>> Action<? super B> parseProperty(
@@ -295,77 +291,14 @@ public <T extends Filterable<?>> MessageAction<?> parseChatMessage(Element el, C
 
     scope = parseScope(el, scope);
 
-    ImmutableMap.Builder<String, MessageAction.Replacement<T>> replacementMap =
-        ImmutableMap.builder();
+    ImmutableMap.Builder<String, Replacement<T>> replacementMap = ImmutableMap.builder();
     for (Element replacement : XMLUtils.flattenElements(el, "replacements")) {
       replacementMap.put(
-          XMLUtils.parseRequiredId(replacement), parseReplacement(replacement, scope));
+          XMLUtils.parseRequiredId(replacement), replacementParser.parse(replacement, scope));
     }
     return new MessageAction<>(scope, text, actionbar, title, replacementMap.build());
   }
 
-  private <T extends Filterable<?>> MessageAction.Replacement<T> parseReplacement(
-      Element el, Class<T> scope) throws InvalidXMLException {
-    // TODO: Support alternative replacement types (eg: player(s), team(s), or durations)
-    switch (el.getName().toLowerCase(Locale.ROOT)) {
-      case "decimal": {
-        Formula<T> formula = parser.formula(scope, el, "value").required();
-        Node formatNode = Node.fromAttr(el, "format");
-        NumberFormat format =
-            formatNode != null ? new DecimalFormat(formatNode.getValue()) : DEFAULT_FORMAT;
-        return (T filterable) -> text(format.format(formula.applyAsDouble(filterable)));
-      }
-      case "player": {
-        var variable = parser.variable(el, "var").scope(MatchPlayer.class).singleExclusive();
-        var fallback = XMLUtils.parseFormattedText(el, "fallback", empty());
-        var nameStyle = parser.parseEnum(NameStyle.class, el, "style").optional(NameStyle.VERBOSE);
-
-        return (T filterable) ->
-            variable.getHolder(filterable).map(mp -> mp.getName(nameStyle)).orElse(fallback);
-      }
-      case "switch": {
-        Formula<T> formula = parser.formula(scope, el, "value").orNull();
-        var fallback = parser.formattedText(el, "fallback").child().optional(empty());
-        var children = el.getChildren("case");
-        var branches = new ArrayList<CaseBranch>(children.size());
-
-        for (var innerEl : children) {
-          var filter = parser.filter(innerEl, "filter").orNull();
-          var valueRange = XMLUtils.parseNumericRange(
-              Node.fromChildOrAttr(innerEl, "match"), Double.class, null);
-          if (filter == null && valueRange == null) {
-            throw new InvalidXMLException(
-                "At least a filter or a value must be specified", innerEl);
-          }
-
-          if (valueRange != null && formula == null) {
-            throw new InvalidXMLException(
-                "A value attribute is specified but there's no switch value to bind to", innerEl);
-          }
-
-          var result = parser.formattedText(innerEl, "result").required();
-
-          branches.add(new CaseBranch(
-              result,
-              valueRange == null ? Range.all() : valueRange,
-              filter == null ? StaticFilter.ALLOW : filter));
-        }
-
-        return (T filterable) -> {
-          var formulaResult = formula == null ? null : formula.applyAsDouble(filterable);
-          for (var branch : branches) {
-            if ((formula == null || branch.valueRange.contains(formulaResult))
-                && branch.filter.query(filterable).isAllowed()) return branch.result;
-          }
-
-          return fallback;
-        };
-      }
-      default:
-        throw new InvalidXMLException("Unknown replacement type", el);
-    }
-  }
-
   @MethodParser("sound")
   public SoundAction parseSoundAction(Element el, Class<?> scope) throws InvalidXMLException {
     SoundType soundType =

diff --git a/core/src/main/java/tc/oc/pgm/action/actions/MessageAction.java b/core/src/main/java/tc/oc/pgm/action/actions/MessageAction.java
@@ -1,13 +1,12 @@
 package tc.oc.pgm.action.actions;
 
 import java.util.Map;
-import java.util.function.Function;
 import java.util.regex.Pattern;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.ComponentLike;
 import net.kyori.adventure.text.TextReplacementConfig;
 import net.kyori.adventure.title.Title;
 import org.jetbrains.annotations.Nullable;
+import tc.oc.pgm.action.replacements.Replacement;
 import tc.oc.pgm.util.Audience;
 
 public class MessageAction<T extends Audience> extends AbstractAction<T> {
@@ -43,22 +42,18 @@ private Component replace(Component component, T scope) {
       return component;
     }
 
-    return component.replaceText(
-        TextReplacementConfig.builder()
-            .match(REPLACEMENT_PATTERN)
-            .replacement(
-                (match, original) -> {
-                  Replacement<T> r = replacements.get(match.group(1));
-                  return r != null ? r.apply(scope) : original;
-                })
-            .build());
+    return component.replaceText(TextReplacementConfig.builder()
+        .match(REPLACEMENT_PATTERN)
+        .replacement((match, original) -> {
+          Replacement<T> r = replacements.get(match.group(1));
+          return r != null ? r.replace(scope) : original;
+        })
+        .build());
   }
 
   private Title replace(Title title, T scope) {
     if (replacements == null) return title;
     return Title.title(
         replace(title.title(), scope), replace(title.subtitle(), scope), title.times());
   }
-
-  public interface Replacement<T extends Audience> extends Function<T, ComponentLike> {}
 }
diff --git a/core/src/main/java/tc/oc/pgm/action/replacements/Replacement.java b/core/src/main/java/tc/oc/pgm/action/replacements/Replacement.java
@@ -0,0 +1,27 @@
+package tc.oc.pgm.action.replacements;
+
+import net.kyori.adventure.text.ComponentLike;
+import tc.oc.pgm.api.feature.FeatureDefinition;
+import tc.oc.pgm.util.Audience;
+
+/**
+ * A replacement object provides replacement text in message actions.
+ *
+ * @param <S> The scope of the replacement
+ */
+public interface Replacement<S extends Audience> extends FeatureDefinition {
+  /**
+   * Gets the scope of the replacement.
+   *
+   * @return The scope of the replacement
+   */
+  Class<S> getScope();
+
+  /**
+   * Creates a replacement component tailored to the given audience.
+   *
+   * @param audience The audience to use when replacing
+   * @return The replacement component
+   */
+  ComponentLike replace(S audience);
+}