From 790222f0b1b871e33876d29b010c80c3927ff3f2 Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Fri, 8 Sep 2023 12:27:27 +0930
Subject: [PATCH 1/6] flesh out dice

---
 .../dicelib/expression/ExpressionParser.java  |   8 +
 .../expression/function/GeneSysDice.java      | 347 ++++++++++++++++++
 .../net/rptools/maptool/client/MapTool.java   |  27 ++
 .../client/fonts/EotE_Symbol-Regular_v1.otf   | Bin 0 -> 4076 bytes
 .../client/fonts/GenesysGlyphsAndDice-3.0.otf | Bin 0 -> 22580 bytes
 5 files changed, 382 insertions(+)
 create mode 100644 src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
 create mode 100644 src/main/resources/net/rptools/maptool/client/fonts/EotE_Symbol-Regular_v1.otf
 create mode 100644 src/main/resources/net/rptools/maptool/client/fonts/GenesysGlyphsAndDice-3.0.otf

diff --git a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
index e96e0fb8ac..0914965051 100755
--- a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
+++ b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
@@ -21,6 +21,7 @@
 import net.rptools.dicelib.expression.function.ExplodeDice;
 import net.rptools.dicelib.expression.function.ExplodingSuccessDice;
 import net.rptools.dicelib.expression.function.FudgeRoll;
+import net.rptools.dicelib.expression.function.GeneSysDice;
 import net.rptools.dicelib.expression.function.HeroKillingRoll;
 import net.rptools.dicelib.expression.function.HeroRoll;
 import net.rptools.dicelib.expression.function.If;
@@ -205,6 +206,12 @@ public class ExpressionParser {
         new String[] {"\\b[aA][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStress($1, $2)"},
         new String[] {"\\b[aA][nN][sS](\\d+)\\b", "arsMagicaStressNum($1, 0)"},
         new String[] {"\\b[aA][nN][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStressNum($1, $2)"},
+
+        // SW FFG
+        new String[] {"\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)\\b", "swffg('$1')"},
+
+        // FFG
+        new String[] {"\\bffg#(([bBsSaAdDpPcC]\\d+)+)\\b", "ffg('$1')"},
       };
 
   private final Parser parser;
@@ -238,6 +245,7 @@ public ExpressionParser(String[][] regexpTransforms) {
     parser.addFunction(new DropHighestRoll());
     parser.addFunction(new KeepLowestRoll());
     parser.addFunction(new ArsMagicaStress());
+    parser.addFunction(new GeneSysDice());
 
     parser.addFunction(new If());
 
diff --git a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
new file mode 100644
index 0000000000..0df6c6629a
--- /dev/null
+++ b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
@@ -0,0 +1,347 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.dicelib.expression.function;
+
+import com.google.gson.Gson;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+import net.rptools.maptool.client.ui.theme.ThemeSupport;
+import net.rptools.maptool.client.ui.theme.ThemeSupport.ThemeColor;
+import net.rptools.parser.Parser;
+import net.rptools.parser.ParserException;
+import net.rptools.parser.VariableResolver;
+import net.rptools.parser.function.AbstractFunction;
+
+public class GeneSysDice extends AbstractFunction {
+
+  enum ResultType {
+    SUCCESS(1, 0, 0, 0, 0, 0, 0, 0, "s"),
+    FAILURE(0, 1, 0, 0, 0, 0, 0, 0, "f"),
+    ADVANTAGE(0, 0, 1, 0, 0, 0, 0, 0, "a"),
+    THREAT(0, 0, 0, 1, 0, 0, 0, 0, "h"),
+    TRIUMPH(1, 0, 0, 0, 1, 0, 0, 0, "t"),
+    DESPAIR(0, 1, 0, 0, 0, 1, 0, 0, "d"),
+    LIGHT(0, 0, 0, 0, 0, 0, 1, 0, "Z"),
+    DARK(0, 0, 0, 0, 0, 0, 0, 1, "z"),
+    NONE(0, 0, 0, 0, 0, 0, 0, 0, " "),
+    SUCCESS_ADVANTAGE(1, 0, 1, 0, 0, 0, 0, 0, "sa"),
+    ADVANTAGE_ADVANTAGE(0, 0, 2, 0, 0, 0, 0, 0, "aa"),
+    SUCCESS_SUCCESS(2, 0, 0, 0, 0, 0, 0, 0, "ss"),
+    FAILURE_THREAT(0, 1, 0, 1, 0, 0, 0, 0, "fh"),
+    FAILURE_FAILURE(0, 2, 0, 0, 0, 0, 0, 0, "ff"),
+    THREAT_THREAT(0, 0, 0, 2, 0, 0, 0, 0, "hh"),
+    LIGHT_LIGHT(0, 0, 0, 0, 0, 0, 2, 0, "ZZ"),
+    DARK_DARK(0, 0, 0, 0, 0, 0, 0, 2, "zz");
+
+    private final int success;
+    private final int failure;
+    private final int advantage;
+    private final int threat;
+    private final int triumph;
+    private final int despair;
+    private final int light;
+    private final int dark;
+
+    private final String fontCharacters;
+
+    ResultType(
+        int success,
+        int failure,
+        int advantage,
+        int threat,
+        int triumph,
+        int despair,
+        int light,
+        int dark,
+        String fontCharacters) {
+      this.success = success;
+      this.failure = failure;
+      this.advantage = advantage;
+      this.threat = threat;
+      this.triumph = triumph;
+      this.despair = despair;
+      this.light = light;
+      this.dark = dark;
+      this.fontCharacters = fontCharacters;
+    }
+
+    public int getSuccess() {
+      return success;
+    }
+
+    public int getFailure() {
+      return failure;
+    }
+
+    public int getAdvantage() {
+      return advantage;
+    }
+
+    public int getThreat() {
+      return threat;
+    }
+
+    public int getTriumph() {
+      return triumph;
+    }
+
+    public int getDespair() {
+      return despair;
+    }
+
+    public int getLight() {
+      return light;
+    }
+
+    public int getDark() {
+      return dark;
+    }
+  }
+
+  private enum DiceType {
+    BOOST(
+        "b",
+        List.of(
+            ResultType.NONE,
+            ResultType.NONE,
+            ResultType.SUCCESS,
+            ResultType.SUCCESS_ADVANTAGE,
+            ResultType.ADVANTAGE_ADVANTAGE,
+            ResultType.ADVANTAGE)),
+
+    SETBACK(
+        "s",
+        List.of(
+            ResultType.NONE,
+            ResultType.NONE,
+            ResultType.FAILURE,
+            ResultType.FAILURE,
+            ResultType.THREAT,
+            ResultType.THREAT)),
+    ABILITY(
+        "a",
+        List.of(
+            ResultType.NONE,
+            ResultType.SUCCESS,
+            ResultType.SUCCESS,
+            ResultType.SUCCESS_SUCCESS,
+            ResultType.ADVANTAGE,
+            ResultType.ADVANTAGE,
+            ResultType.SUCCESS_ADVANTAGE,
+            ResultType.ADVANTAGE_ADVANTAGE)),
+    DIFFICULTY(
+        "d",
+        List.of(
+            ResultType.NONE,
+            ResultType.FAILURE,
+            ResultType.FAILURE_FAILURE,
+            ResultType.THREAT,
+            ResultType.THREAT,
+            ResultType.THREAT,
+            ResultType.THREAT_THREAT,
+            ResultType.FAILURE_THREAT)),
+    PROFICIENCY(
+        "p",
+        List.of(
+            ResultType.NONE,
+            ResultType.SUCCESS,
+            ResultType.SUCCESS,
+            ResultType.SUCCESS_SUCCESS,
+            ResultType.SUCCESS_SUCCESS,
+            ResultType.ADVANTAGE,
+            ResultType.SUCCESS_ADVANTAGE,
+            ResultType.SUCCESS_ADVANTAGE,
+            ResultType.SUCCESS_ADVANTAGE,
+            ResultType.ADVANTAGE_ADVANTAGE,
+            ResultType.ADVANTAGE_ADVANTAGE,
+            ResultType.TRIUMPH)),
+    CHALLENGE(
+        "c",
+        List.of(
+            ResultType.NONE,
+            ResultType.FAILURE,
+            ResultType.FAILURE,
+            ResultType.FAILURE_FAILURE,
+            ResultType.FAILURE_FAILURE,
+            ResultType.THREAT,
+            ResultType.THREAT,
+            ResultType.FAILURE_THREAT,
+            ResultType.FAILURE_THREAT,
+            ResultType.THREAT_THREAT,
+            ResultType.THREAT_THREAT,
+            ResultType.DESPAIR)),
+    FORCE(
+        "f",
+        List.of(
+            ResultType.DARK,
+            ResultType.DARK,
+            ResultType.DARK,
+            ResultType.DARK,
+            ResultType.DARK,
+            ResultType.DARK,
+            ResultType.DARK_DARK,
+            ResultType.LIGHT,
+            ResultType.LIGHT,
+            ResultType.LIGHT_LIGHT,
+            ResultType.LIGHT_LIGHT,
+            ResultType.LIGHT_LIGHT));
+
+    private final List<ResultType> sides;
+    private final String diePattern;
+
+    DiceType(String diePattern, List<ResultType> sides) {
+      this.sides = sides;
+      this.diePattern = diePattern;
+    }
+
+    public String getDiePattern() {
+      return diePattern;
+    }
+
+    public int getSides() {
+      return sides.size();
+    }
+
+    public ResultType roll() {
+      return getSide(DiceHelper.rollDice(1, sides.size()) - 1);
+    }
+
+    public ResultType getSide(int side) {
+      return sides.get(side);
+    }
+    ;
+  }
+
+  private static final Map<String, String> FFG_FONT_NAME_MAP =
+      Map.of("swffg", "EotE Symbol", "ffg", "Genesys Glyphs and Dice");
+
+  private static final String BOOST_DIE_PATTERN_NAME = "boost";
+  private static final String SETBACK_DIE_PATTERN_NAME = "setback";
+  private static final String ABILITY_DIE_PATTERN_NAME = "ability";
+  private static final String DIFFICULTY_DIE_PATTERN_NAME = "difficulty";
+  private static final String PROFICIENCY_DIE_PATTERN_NAME = "proficiency";
+  private static final String CHALLENGE_DIE_PATTERN_NAME = "challenge";
+  private static final String FORCE_DIE_PATTERN_NAME = "force";
+
+  public GeneSysDice() {
+    super(1, 1, false, "swffg", "ffg");
+  }
+
+  @Override
+  public Object childEvaluate(
+      Parser parser, VariableResolver resolver, String functionName, List<Object> parameters)
+      throws ParserException {
+
+    var diceString = parameters.get(0).toString().toLowerCase();
+
+    var pattern = Pattern.compile("(\\S)(\\d+)");
+    var matcher = pattern.matcher(diceString);
+    var results = new ArrayList<ResultType>();
+    var individualResults = new HashMap<String, List<String>>();
+
+    while (matcher.find()) {
+      var dieType = matcher.group(1);
+      var dieCount = Integer.parseInt(matcher.group(2));
+      var die =
+          Arrays.stream(DiceType.values())
+              .filter(dt -> dt.diePattern.equalsIgnoreCase(dieType))
+              .findFirst()
+              .get();
+      for (int i = 0; i < dieCount; i++) {
+        var roll = die.roll();
+        results.add(roll);
+        var dieName = die.name().toLowerCase();
+        individualResults.putIfAbsent(dieName, new ArrayList<>());
+        individualResults.get(dieName).add(roll.name().toLowerCase());
+      }
+    }
+
+    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
+
+    var sb = new StringBuilder();
+    sb.append("<font face='")
+        .append(FFG_FONT_NAME_MAP.get(functionName))
+        .append("' size ='+1' color='")
+        .append(gray)
+        .append("'>");
+    for (var result : results) {
+      sb.append(result.fontCharacters);
+    }
+    sb.append("</span>");
+
+    // Set variable with result
+    var resultMap = new HashMap<String, Integer>();
+    for (var result : results) {
+      var resultString = result.toString().toLowerCase();
+      resultMap.put(resultString, resultMap.getOrDefault(resultString, 0) + 1);
+    }
+
+    int successCount = 0;
+    int failureCount = 0;
+    int advantageCount = 0;
+    int threatCount = 0;
+    int triumphCount = 0;
+    int despairCount = 0;
+    int lightCount = 0;
+    int darkCount = 0;
+
+    for (var result : results) {
+      successCount += result.getSuccess();
+      failureCount += result.getFailure();
+      advantageCount += result.getAdvantage();
+      threatCount += result.getThreat();
+      triumphCount += result.getTriumph();
+      despairCount += result.getDespair();
+      lightCount += result.getLight();
+      darkCount += result.getDark();
+    }
+
+    var counters = new HashMap<String, Integer>();
+    counters.put("success", successCount);
+    counters.put("failure", failureCount);
+    counters.put("advantage", advantageCount);
+    counters.put("threat", threatCount);
+    counters.put("triumph", triumphCount);
+    counters.put("despair", despairCount);
+    if (lightCount > 0) {
+      counters.put("light", lightCount);
+    }
+    if (darkCount > 0) {
+      counters.put("dark", darkCount);
+    }
+
+    var result = new HashMap<String, Integer>();
+    result.put("success", successCount - failureCount);
+    result.put("advantage", advantageCount - threatCount);
+    result.put("triumph", triumphCount);
+    result.put("despair", despairCount);
+    if (lightCount > 0 || darkCount > 0) {
+      result.put("force", lightCount - darkCount);
+    }
+
+    var gson = new Gson().toJsonTree(resultMap).getAsJsonObject();
+    gson.add("rolls", new Gson().toJsonTree(individualResults).getAsJsonObject());
+    gson.add("counters", new Gson().toJsonTree(counters).getAsJsonObject());
+    gson.add("result", new Gson().toJsonTree(result).getAsJsonObject());
+
+    resolver.setVariable("lastFFGResult", gson);
+
+    return sb.toString();
+  }
+}
diff --git a/src/main/java/net/rptools/maptool/client/MapTool.java b/src/main/java/net/rptools/maptool/client/MapTool.java
index e740218d23..eb58d8e464 100644
--- a/src/main/java/net/rptools/maptool/client/MapTool.java
+++ b/src/main/java/net/rptools/maptool/client/MapTool.java
@@ -1804,6 +1804,33 @@ public static void main(String[] args) {
       System.exit(1);
     }
 
+    /*
+     * Load GenSys and SW RPG fonts
+     */
+    try {
+      var genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
+      var genFont =
+          Font.createFont(
+              Font.TRUETYPE_FONT,
+              Objects.requireNonNull(
+                  MapTool.class
+                      .getClassLoader()
+                      .getResourceAsStream(
+                          "net/rptools/maptool/client/fonts/GenesysGlyphsAndDice-3.0.otf")));
+      genv.registerFont(genFont);
+      var swGenFont =
+          Font.createFont(
+              Font.TRUETYPE_FONT,
+              Objects.requireNonNull(
+                  MapTool.class
+                      .getClassLoader()
+                      .getResourceAsStream(
+                          "net/rptools/maptool/client/fonts/EotE_Symbol-Regular_v1.otf")));
+      genv.registerFont(swGenFont);
+    } catch (Exception e) {
+      log.error("msg.error.genesysFont", e);
+    }
+
     /**
      * This is a tweak that makes the Chinese version work better.
      *
diff --git a/src/main/resources/net/rptools/maptool/client/fonts/EotE_Symbol-Regular_v1.otf b/src/main/resources/net/rptools/maptool/client/fonts/EotE_Symbol-Regular_v1.otf
new file mode 100644
index 0000000000000000000000000000000000000000..ea1ebfcc76bedd719ef1d9f2b91ef5ff0911f259
GIT binary patch
literal 4076
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

literal 0
HcmV?d00001

diff --git a/src/main/resources/net/rptools/maptool/client/fonts/GenesysGlyphsAndDice-3.0.otf b/src/main/resources/net/rptools/maptool/client/fonts/GenesysGlyphsAndDice-3.0.otf
new file mode 100644
index 0000000000000000000000000000000000000000..88fa4c37ca242fa8cfe0eb1cd41f517e6aee8748
GIT binary patch
literal 22580
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
Ad;kCd

literal 0
HcmV?d00001


From d1b0bf2e0de021dfbea00a6ad4e95d8d344b0b98 Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Fri, 8 Sep 2023 23:18:43 +0930
Subject: [PATCH 2/6] add roll expression for retreiving results in different
 formats

---
 .../dicelib/expression/ExpressionParser.java  |  16 +-
 .../expression/function/GeneSysDice.java      | 333 ++++++++++++++++--
 2 files changed, 319 insertions(+), 30 deletions(-)

diff --git a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
index 0914965051..fd58800b30 100755
--- a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
+++ b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
@@ -207,11 +207,17 @@ public class ExpressionParser {
         new String[] {"\\b[aA][nN][sS](\\d+)\\b", "arsMagicaStressNum($1, 0)"},
         new String[] {"\\b[aA][nN][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStressNum($1, $2)"},
 
-        // SW FFG
-        new String[] {"\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)\\b", "swffg('$1')"},
-
-        // FFG
-        new String[] {"\\bffg#(([bBsSaAdDpPcC]\\d+)+)\\b", "ffg('$1')"},
+        // SW Genesys
+        new String[] {"\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)\\b", "swgenesys('$1')"},
+        new String[] {"\\bsw#details\\b", "swgenesysLastDetails()"},
+        new String[] {"\\bsw#rolls\\b", "swgenesysLastRolls()"},
+        new String[] {"\\bsw#grouped\\b", "swgenesysLastGrouped()"},
+
+        // Genesys
+        new String[] {"\\bgs#(([bBsSaAdDpPcC]\\d+)+)\\b", "genesys('$1')"},
+        new String[] {"\\bgs#details\\b", "genesysLastDetails()"},
+        new String[] {"\\bgs#rolls\\b", "genesysLastRolls()"},
+        new String[] {"\\bgs#grouped\\b", "genesysLastGrouped()"},
       };
 
   private final Parser parser;
diff --git a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
index 0df6c6629a..1836af56c7 100644
--- a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
+++ b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
@@ -15,12 +15,15 @@
 package net.rptools.dicelib.expression.function;
 
 import com.google.gson.Gson;
+import com.google.gson.JsonObject;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Pattern;
+import java.util.stream.StreamSupport;
 import net.rptools.maptool.client.ui.theme.ThemeSupport;
 import net.rptools.maptool.client.ui.theme.ThemeSupport.ThemeColor;
 import net.rptools.parser.Parser;
@@ -28,38 +31,79 @@
 import net.rptools.parser.VariableResolver;
 import net.rptools.parser.function.AbstractFunction;
 
+/** This class implements the dice rolling functions for genesys / starwars genesys systems. */
 public class GeneSysDice extends AbstractFunction {
 
+  /** Enumeration of the possible results of a die roll. */
   enum ResultType {
+    /** A single success. */
     SUCCESS(1, 0, 0, 0, 0, 0, 0, 0, "s"),
+    /** A single failure. */
     FAILURE(0, 1, 0, 0, 0, 0, 0, 0, "f"),
+    /** A single advantage. */
     ADVANTAGE(0, 0, 1, 0, 0, 0, 0, 0, "a"),
+    /** A single threat. */
     THREAT(0, 0, 0, 1, 0, 0, 0, 0, "h"),
+    /** A single triumph. */
     TRIUMPH(1, 0, 0, 0, 1, 0, 0, 0, "t"),
+    /** A single despair. */
     DESPAIR(0, 1, 0, 0, 0, 1, 0, 0, "d"),
+    /* A single light side point. */
     LIGHT(0, 0, 0, 0, 0, 0, 1, 0, "Z"),
+    /** A single dark side point. */
     DARK(0, 0, 0, 0, 0, 0, 0, 1, "z"),
+    /** No result. */
     NONE(0, 0, 0, 0, 0, 0, 0, 0, " "),
+    /** A single success and a single advantage. */
     SUCCESS_ADVANTAGE(1, 0, 1, 0, 0, 0, 0, 0, "sa"),
+    /** Two Advantages. */
     ADVANTAGE_ADVANTAGE(0, 0, 2, 0, 0, 0, 0, 0, "aa"),
+    /** Two Successes. */
     SUCCESS_SUCCESS(2, 0, 0, 0, 0, 0, 0, 0, "ss"),
+    /* A single failure and a single threat. */
     FAILURE_THREAT(0, 1, 0, 1, 0, 0, 0, 0, "fh"),
+    /** Two Failures. */
     FAILURE_FAILURE(0, 2, 0, 0, 0, 0, 0, 0, "ff"),
+    /** Two Threats. */
     THREAT_THREAT(0, 0, 0, 2, 0, 0, 0, 0, "hh"),
+    /** Two Light Side Points. */
     LIGHT_LIGHT(0, 0, 0, 0, 0, 0, 2, 0, "ZZ"),
+    /** Two Dark Side Points. */
     DARK_DARK(0, 0, 0, 0, 0, 0, 0, 2, "zz");
 
+    /** The number of successes this result represents. */
     private final int success;
+    /** The number of failures this result represents. */
     private final int failure;
+    /** The number of advantages this result represents. */
     private final int advantage;
+    /** The number of threats this result represents. */
     private final int threat;
+    /** The number of triumphs this result represents. */
     private final int triumph;
+    /** The number of despairs this result represents. */
     private final int despair;
+    /** The number of light side points this result represents. */
     private final int light;
+    /** The number of dark side points this result represents. */
     private final int dark;
 
+    /** The font characters that represent this result. */
     private final String fontCharacters;
 
+    /**
+     * Constructor.
+     *
+     * @param success the number of successes this result represents.
+     * @param failure the number of failures this result represents.
+     * @param advantage the number of advantages this result represents.
+     * @param threat the number of threats this result represents.
+     * @param triumph the number of triumphs this result represents.
+     * @param despair the number of despairs this result represents.
+     * @param light the number of light side points this result represents.
+     * @param dark the number of dark side points this result represents.
+     * @param fontCharacters the font characters that represent this result.
+     */
     ResultType(
         int success,
         int failure,
@@ -81,42 +125,85 @@ enum ResultType {
       this.fontCharacters = fontCharacters;
     }
 
+    /**
+     * Get the number of successes this result represents.
+     *
+     * @return the number of successes this result represents.
+     */
     public int getSuccess() {
       return success;
     }
 
+    /**
+     * Get the number of failures this result represents.
+     *
+     * @return the number of failures this result represents.
+     */
     public int getFailure() {
       return failure;
     }
 
+    /**
+     * Get the number of advantages this result represents.
+     *
+     * @return the number of advantages this result represents.
+     */
     public int getAdvantage() {
       return advantage;
     }
 
+    /**
+     * Get the number of threats this result represents.
+     *
+     * @return the number of threats this result represents.
+     */
     public int getThreat() {
       return threat;
     }
 
+    /**
+     * Get the number of triumphs this result represents.
+     *
+     * @return the number of triumphs this result represents.
+     */
     public int getTriumph() {
       return triumph;
     }
 
+    /**
+     * Get the number of despairs this result represents.
+     *
+     * @return the number of despairs this result represents.
+     */
     public int getDespair() {
       return despair;
     }
 
+    /**
+     * Get the number of light side points this result represents.
+     *
+     * @return the number of light side points this result represents.
+     */
     public int getLight() {
       return light;
     }
 
+    /**
+     * Get the number of dark side points this result represents.
+     *
+     * @return the number of dark side points this result represents.
+     */
     public int getDark() {
       return dark;
     }
   }
 
+  /** Enumeration of the possible dice types. */
   private enum DiceType {
+    /** The boost die. */
     BOOST(
         "b",
+        0,
         List.of(
             ResultType.NONE,
             ResultType.NONE,
@@ -125,8 +212,10 @@ private enum DiceType {
             ResultType.ADVANTAGE_ADVANTAGE,
             ResultType.ADVANTAGE)),
 
+    /** The setback die. */
     SETBACK(
         "s",
+        1,
         List.of(
             ResultType.NONE,
             ResultType.NONE,
@@ -134,8 +223,10 @@ private enum DiceType {
             ResultType.FAILURE,
             ResultType.THREAT,
             ResultType.THREAT)),
+    /** The ability die. */
     ABILITY(
         "a",
+        2,
         List.of(
             ResultType.NONE,
             ResultType.SUCCESS,
@@ -145,8 +236,10 @@ private enum DiceType {
             ResultType.ADVANTAGE,
             ResultType.SUCCESS_ADVANTAGE,
             ResultType.ADVANTAGE_ADVANTAGE)),
+    /** The difficulty die. */
     DIFFICULTY(
         "d",
+        3,
         List.of(
             ResultType.NONE,
             ResultType.FAILURE,
@@ -156,8 +249,10 @@ private enum DiceType {
             ResultType.THREAT,
             ResultType.THREAT_THREAT,
             ResultType.FAILURE_THREAT)),
+    /** The proficiency die. */
     PROFICIENCY(
         "p",
+        4,
         List.of(
             ResultType.NONE,
             ResultType.SUCCESS,
@@ -171,8 +266,10 @@ private enum DiceType {
             ResultType.ADVANTAGE_ADVANTAGE,
             ResultType.ADVANTAGE_ADVANTAGE,
             ResultType.TRIUMPH)),
+    /* The challenge die. */
     CHALLENGE(
         "c",
+        5,
         List.of(
             ResultType.NONE,
             ResultType.FAILURE,
@@ -186,8 +283,10 @@ private enum DiceType {
             ResultType.THREAT_THREAT,
             ResultType.THREAT_THREAT,
             ResultType.DESPAIR)),
+    /** The force die. */
     FORCE(
         "f",
+        6,
         List.of(
             ResultType.DARK,
             ResultType.DARK,
@@ -202,45 +301,97 @@ private enum DiceType {
             ResultType.LIGHT_LIGHT,
             ResultType.LIGHT_LIGHT));
 
+    /** The sides of the die. */
     private final List<ResultType> sides;
+
+    /** The pattern used to represent this die. */
     private final String diePattern;
 
-    DiceType(String diePattern, List<ResultType> sides) {
+    /** The sort order of the die when grouped, */
+    private final int groupSort;
+
+    /**
+     * Constructor.
+     *
+     * @param diePattern the pattern used to represent this die.
+     * @param groupSort the sort order of the die when grouped.
+     * @param sides the sides of the die.
+     */
+    DiceType(String diePattern, int groupSort, List<ResultType> sides) {
       this.sides = sides;
+      this.groupSort = groupSort;
       this.diePattern = diePattern;
     }
 
+    /**
+     * Get the pattern used to represent this die.
+     *
+     * @return the pattern used to represent this die.
+     */
     public String getDiePattern() {
       return diePattern;
     }
 
+    /**
+     * Get the number of sides on this die.
+     *
+     * @return the number of sides on this die.
+     */
     public int getSides() {
       return sides.size();
     }
 
+    /**
+     * Roll the die.
+     *
+     * @return the result of the roll.
+     */
     public ResultType roll() {
       return getSide(DiceHelper.rollDice(1, sides.size()) - 1);
     }
 
+    /**
+     * Get the result of a roll of the die.
+     *
+     * @param side the side of the die to get the result for.
+     * @return the result of the roll.
+     */
     public ResultType getSide(int side) {
       return sides.get(side);
     }
-    ;
+
+    /**
+     * Get the sort order of the die when grouped.
+     *
+     * @return the sort order of the die when grouped.
+     */
+    public int getGroupSort() {
+      return groupSort;
+    }
   }
 
-  private static final Map<String, String> FFG_FONT_NAME_MAP =
-      Map.of("swffg", "EotE Symbol", "ffg", "Genesys Glyphs and Dice");
+  /** Map of font names for the different systems. */
+  private static final Map<String, String> GS_FONT_NAME_MAP =
+      Map.of("swgenesys", "EotE Symbol", "genesys", "Genesys Glyphs and Dice");
 
-  private static final String BOOST_DIE_PATTERN_NAME = "boost";
-  private static final String SETBACK_DIE_PATTERN_NAME = "setback";
-  private static final String ABILITY_DIE_PATTERN_NAME = "ability";
-  private static final String DIFFICULTY_DIE_PATTERN_NAME = "difficulty";
-  private static final String PROFICIENCY_DIE_PATTERN_NAME = "proficiency";
-  private static final String CHALLENGE_DIE_PATTERN_NAME = "challenge";
-  private static final String FORCE_DIE_PATTERN_NAME = "force";
+  /** Map of variable names for the different systems. */
+  private static final Map<String, String> ROLL_VARIABLE_MAP =
+      Map.of("swgenesys", "#lastSWResult", "genesys", "#lastGSResult");
 
+  /** Constructor. */
   public GeneSysDice() {
-    super(1, 1, false, "swffg", "ffg");
+    super(
+        0,
+        1,
+        false,
+        "swgenesys",
+        "genesys",
+        "swgenesyslastdetails",
+        "genesyslastdetails",
+        "swgenesyslastrolls",
+        "genesyslastrolls",
+        "swgenesyslastgrouped",
+        "genesyslastgrouped");
   }
 
   @Override
@@ -248,6 +399,126 @@ public Object childEvaluate(
       Parser parser, VariableResolver resolver, String functionName, List<Object> parameters)
       throws ParserException {
 
+    return switch (functionName.toLowerCase()) {
+      case "swgenesys", "genesys" -> performRoll(functionName, resolver, parameters);
+      case "swgenesyslastdetails", "genesyslastdetails" -> returnDetails(
+          functionName.toLowerCase().replace("lastdetails", ""), resolver);
+      case "swgenesyslastrolls", "genesyslastrolls" -> renderRolls(
+          functionName.toLowerCase().replace("lastrolls", ""), resolver);
+      case "swgenesyslastgrouped", "genesyslastgrouped" -> renderGrouped(
+          functionName.toLowerCase().replace("lastgrouped", ""), resolver);
+      default -> // Should never happen
+      throw new ParserException("Invalid function name: " + functionName);
+    };
+  }
+
+  /**
+   * Render the results of a roll.
+   *
+   * @param functionName the name of the function.
+   * @param resolver the variable resolver.
+   * @return the rendered results.
+   * @throws ParserException if an error occurs.
+   */
+  private String renderGrouped(String functionName, VariableResolver resolver)
+      throws ParserException {
+    var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
+    var rollsMap = new HashMap<String, List<String>>();
+    for (var entry : rollResults.get("rolls").getAsJsonObject().entrySet()) {
+      var dieName = entry.getKey();
+      var rolls =
+          StreamSupport.stream(entry.getValue().getAsJsonArray().spliterator(), false)
+              .map(r -> r.getAsString().toLowerCase())
+              .toList();
+      rollsMap.put(dieName, rolls);
+    }
+    return renderGrouped(functionName, rollsMap);
+  }
+
+  /**
+   * Render the results of a roll to a string.
+   *
+   * @param functionName the name of the function.
+   * @param rolls the rolls to render.
+   * @return the rendered results.
+   */
+  private String renderGrouped(String functionName, Map<String, List<String>> rolls) {
+    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
+    var sb = new StringBuilder();
+    sb.append("<span style='color:").append(gray).append("'>");
+    var dieTypes =
+        Arrays.stream(DiceType.values())
+            .sorted(Comparator.comparingInt(DiceType::getGroupSort))
+            .toList();
+    boolean first = true;
+    for (var dt : dieTypes) {
+      var dieName = dt.name().toLowerCase();
+      if (rolls.containsKey(dieName)) {
+        if (!first) {
+          sb.append(", ");
+        }
+        first = false;
+        sb.append(dieName).append(": ");
+        var dieRolls =
+            rolls.get(dieName).stream().map(r -> ResultType.valueOf(r.toUpperCase())).toList();
+        sb.append(renderRolls(functionName, dieRolls));
+      }
+      sb.append("</span>");
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Render the results of a roll to a string.
+   *
+   * @param functionName the name of the function.
+   * @param resolver the variable resolver.
+   * @return the rendered results.
+   * @throws ParserException if an error occurs.
+   */
+  private String renderRolls(String functionName, VariableResolver resolver)
+      throws ParserException {
+    var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
+    var rolls =
+        StreamSupport.stream(
+                rollResults
+                    .get("rolls")
+                    .getAsJsonObject()
+                    .get("all")
+                    .getAsJsonArray()
+                    .spliterator(),
+                false)
+            .map(r -> ResultType.valueOf(r.getAsString().toUpperCase()))
+            .toList();
+    return renderRolls(functionName, rolls);
+  }
+
+  /**
+   * Return the details of the last roll.
+   *
+   * @param functionName the name of the function.
+   * @param resolver the variable resolver.
+   * @return the details of the last roll.
+   * @throws ParserException if an error occurs.
+   */
+  private JsonObject returnDetails(String functionName, VariableResolver resolver)
+      throws ParserException {
+    return (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
+  }
+
+  /**
+   * Perform a roll.
+   *
+   * @param functionName the name of the function.
+   * @param resolver the variable resolver.
+   * @param parameters the parameters to the function.
+   * @return the rendered results.
+   * @throws ParserException if an error occurs.
+   */
+  private String performRoll(
+      String functionName, VariableResolver resolver, List<Object> parameters)
+      throws ParserException {
+
     var diceString = parameters.get(0).toString().toLowerCase();
 
     var pattern = Pattern.compile("(\\S)(\\d+)");
@@ -272,18 +543,7 @@ public Object childEvaluate(
       }
     }
 
-    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
-
-    var sb = new StringBuilder();
-    sb.append("<font face='")
-        .append(FFG_FONT_NAME_MAP.get(functionName))
-        .append("' size ='+1' color='")
-        .append(gray)
-        .append("'>");
-    for (var result : results) {
-      sb.append(result.fontCharacters);
-    }
-    sb.append("</span>");
+    individualResults.put("all", results.stream().map(r -> r.name().toLowerCase()).toList());
 
     // Set variable with result
     var resultMap = new HashMap<String, Integer>();
@@ -340,8 +600,31 @@ public Object childEvaluate(
     gson.add("counters", new Gson().toJsonTree(counters).getAsJsonObject());
     gson.add("result", new Gson().toJsonTree(result).getAsJsonObject());
 
-    resolver.setVariable("lastFFGResult", gson);
+    resolver.setVariable(ROLL_VARIABLE_MAP.get(functionName), gson);
 
+    return renderRolls(functionName, results);
+  }
+
+  /**
+   * Render the results of a roll to a string.
+   *
+   * @param functionName the name of the function.
+   * @param results the results to render.
+   * @return the rendered results.
+   */
+  private String renderRolls(String functionName, List<ResultType> results) {
+    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
+
+    var sb = new StringBuilder();
+    sb.append("<font face='")
+        .append(GS_FONT_NAME_MAP.get(functionName))
+        .append("' size ='+1' color='")
+        .append(gray)
+        .append("'>");
+    for (var result : results) {
+      sb.append(result.fontCharacters);
+    }
+    sb.append("</font>");
     return sb.toString();
   }
 }

From 152662217207d294b62cd1e541b2d5c881b9516f Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Sat, 9 Sep 2023 23:07:32 +0930
Subject: [PATCH 3/6] implement formatting options

---
 .../dicelib/expression/ExpressionParser.java  |  16 +-
 .../expression/function/GeneSysDice.java      | 222 ++++++++++++++----
 2 files changed, 181 insertions(+), 57 deletions(-)

diff --git a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
index fd58800b30..84f45dc425 100755
--- a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
+++ b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
@@ -208,16 +208,16 @@ public class ExpressionParser {
         new String[] {"\\b[aA][nN][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStressNum($1, $2)"},
 
         // SW Genesys
-        new String[] {"\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)\\b", "swgenesys('$1')"},
-        new String[] {"\\bsw#details\\b", "swgenesysLastDetails()"},
-        new String[] {"\\bsw#rolls\\b", "swgenesysLastRolls()"},
-        new String[] {"\\bsw#grouped\\b", "swgenesysLastGrouped()"},
+        new String[] {
+          "\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)(\\.(([eEgGdDjJ])+))?\\b", "swgenesys('$1', '$4')"
+        },
+        new String[] {"\\bsw#last(\\.(([eEgGdDjJ])+))*\\b", "swgenesysLast('last', '$2')"},
 
         // Genesys
-        new String[] {"\\bgs#(([bBsSaAdDpPcC]\\d+)+)\\b", "genesys('$1')"},
-        new String[] {"\\bgs#details\\b", "genesysLastDetails()"},
-        new String[] {"\\bgs#rolls\\b", "genesysLastRolls()"},
-        new String[] {"\\bgs#grouped\\b", "genesysLastGrouped()"},
+        new String[] {
+          "\\bgs#(([bBsSaAdDpPcCjJ]\\d+)+)(\\.(([eEgGdD])+))?\\b", "genesys('$1', " + "'$4')"
+        },
+        new String[] {"\\bgs#last(\\.(([eEgGdDj])+))*\\b", "genesysLast('last', '$2')"}
       };
 
   private final Parser parser;
diff --git a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
index 1836af56c7..0283dd085b 100644
--- a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
+++ b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
@@ -20,8 +20,10 @@
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.StreamSupport;
 import net.rptools.maptool.client.ui.theme.ThemeSupport;
@@ -37,39 +39,39 @@ public class GeneSysDice extends AbstractFunction {
   /** Enumeration of the possible results of a die roll. */
   enum ResultType {
     /** A single success. */
-    SUCCESS(1, 0, 0, 0, 0, 0, 0, 0, "s"),
+    SUCCESS(1, 0, 0, 0, 0, 0, 0, 0, "s", 1),
     /** A single failure. */
-    FAILURE(0, 1, 0, 0, 0, 0, 0, 0, "f"),
+    FAILURE(0, 1, 0, 0, 0, 0, 0, 0, "f", 2),
     /** A single advantage. */
-    ADVANTAGE(0, 0, 1, 0, 0, 0, 0, 0, "a"),
+    ADVANTAGE(0, 0, 1, 0, 0, 0, 0, 0, "a", 3),
     /** A single threat. */
-    THREAT(0, 0, 0, 1, 0, 0, 0, 0, "h"),
+    THREAT(0, 0, 0, 1, 0, 0, 0, 0, "h", 4),
     /** A single triumph. */
-    TRIUMPH(1, 0, 0, 0, 1, 0, 0, 0, "t"),
+    TRIUMPH(1, 0, 0, 0, 1, 0, 0, 0, "t", 5),
     /** A single despair. */
-    DESPAIR(0, 1, 0, 0, 0, 1, 0, 0, "d"),
+    DESPAIR(0, 1, 0, 0, 0, 1, 0, 0, "d", 6),
     /* A single light side point. */
-    LIGHT(0, 0, 0, 0, 0, 0, 1, 0, "Z"),
+    LIGHT(0, 0, 0, 0, 0, 0, 1, 0, "Z", 7),
     /** A single dark side point. */
-    DARK(0, 0, 0, 0, 0, 0, 0, 1, "z"),
+    DARK(0, 0, 0, 0, 0, 0, 0, 1, "z", 8),
     /** No result. */
-    NONE(0, 0, 0, 0, 0, 0, 0, 0, " "),
+    NONE(0, 0, 0, 0, 0, 0, 0, 0, " ", 99),
     /** A single success and a single advantage. */
-    SUCCESS_ADVANTAGE(1, 0, 1, 0, 0, 0, 0, 0, "sa"),
+    SUCCESS_ADVANTAGE(1, 0, 1, 0, 0, 0, 0, 0, "sa", 99),
     /** Two Advantages. */
-    ADVANTAGE_ADVANTAGE(0, 0, 2, 0, 0, 0, 0, 0, "aa"),
+    ADVANTAGE_ADVANTAGE(0, 0, 2, 0, 0, 0, 0, 0, "aa", 99),
     /** Two Successes. */
-    SUCCESS_SUCCESS(2, 0, 0, 0, 0, 0, 0, 0, "ss"),
+    SUCCESS_SUCCESS(2, 0, 0, 0, 0, 0, 0, 0, "ss", 99),
     /* A single failure and a single threat. */
-    FAILURE_THREAT(0, 1, 0, 1, 0, 0, 0, 0, "fh"),
+    FAILURE_THREAT(0, 1, 0, 1, 0, 0, 0, 0, "fh", 99),
     /** Two Failures. */
-    FAILURE_FAILURE(0, 2, 0, 0, 0, 0, 0, 0, "ff"),
+    FAILURE_FAILURE(0, 2, 0, 0, 0, 0, 0, 0, "ff", 99),
     /** Two Threats. */
-    THREAT_THREAT(0, 0, 0, 2, 0, 0, 0, 0, "hh"),
+    THREAT_THREAT(0, 0, 0, 2, 0, 0, 0, 0, "hh", 99),
     /** Two Light Side Points. */
-    LIGHT_LIGHT(0, 0, 0, 0, 0, 0, 2, 0, "ZZ"),
+    LIGHT_LIGHT(0, 0, 0, 0, 0, 0, 2, 0, "ZZ", 99),
     /** Two Dark Side Points. */
-    DARK_DARK(0, 0, 0, 0, 0, 0, 0, 2, "zz");
+    DARK_DARK(0, 0, 0, 0, 0, 0, 0, 2, "zz", 99);
 
     /** The number of successes this result represents. */
     private final int success;
@@ -91,6 +93,9 @@ enum ResultType {
     /** The font characters that represent this result. */
     private final String fontCharacters;
 
+    /** The sort order of the result when grouped. */
+    private final int groupSort;
+
     /**
      * Constructor.
      *
@@ -103,6 +108,7 @@ enum ResultType {
      * @param light the number of light side points this result represents.
      * @param dark the number of dark side points this result represents.
      * @param fontCharacters the font characters that represent this result.
+     * @param groupSort the sort order of the result when grouped.
      */
     ResultType(
         int success,
@@ -113,7 +119,8 @@ enum ResultType {
         int despair,
         int light,
         int dark,
-        String fontCharacters) {
+        String fontCharacters,
+        int groupSort) {
       this.success = success;
       this.failure = failure;
       this.advantage = advantage;
@@ -123,6 +130,7 @@ enum ResultType {
       this.light = light;
       this.dark = dark;
       this.fontCharacters = fontCharacters;
+      this.groupSort = groupSort;
     }
 
     /**
@@ -196,6 +204,15 @@ public int getLight() {
     public int getDark() {
       return dark;
     }
+
+    /**
+     * Get the font characters that represent this result.
+     *
+     * @return the font characters that represent this result.
+     */
+    public int getGroupSort() {
+      return groupSort;
+    }
   }
 
   /** Enumeration of the possible dice types. */
@@ -370,6 +387,34 @@ public int getGroupSort() {
     }
   }
 
+  /** Enumeration of the possible options for the dice roll. */
+  private enum Options {
+    /** Group the rolls by die type. */
+    FORMAT_GROUP_DICE("d"),
+    /** Group the rolls by result. */
+    FORMAT_GROUP_RESULTS("g"),
+    /** print out the rolls in expanded format. */
+    EXPANDED_FORMAT("e"),
+    /** Return the results as JSON. */
+    FORMAT_JSON("j");
+
+    /** The string used to represent this option. */
+    private final String optionString;
+
+    Options(String optionString) {
+      this.optionString = optionString;
+    }
+
+    /**
+     * Get the string used to represent this option.
+     *
+     * @return the string used to represent this option.
+     */
+    public String getOptionString() {
+      return optionString;
+    }
+  }
+
   /** Map of font names for the different systems. */
   private static final Map<String, String> GS_FONT_NAME_MAP =
       Map.of("swgenesys", "EotE Symbol", "genesys", "Genesys Glyphs and Dice");
@@ -380,18 +425,7 @@ public int getGroupSort() {
 
   /** Constructor. */
   public GeneSysDice() {
-    super(
-        0,
-        1,
-        false,
-        "swgenesys",
-        "genesys",
-        "swgenesyslastdetails",
-        "genesyslastdetails",
-        "swgenesyslastrolls",
-        "genesyslastrolls",
-        "swgenesyslastgrouped",
-        "genesyslastgrouped");
+    super(1, 2, false, "swgenesys", "genesys", "swgenesyslast", "genesyslast");
   }
 
   @Override
@@ -399,28 +433,55 @@ public Object childEvaluate(
       Parser parser, VariableResolver resolver, String functionName, List<Object> parameters)
       throws ParserException {
 
+    var options = new HashSet<Options>();
+    if (parameters.size() > 1) {
+      var optionsString = parameters.get(1).toString().toLowerCase();
+      for (var option : Options.values()) {
+        if (optionsString.contains(option.getOptionString())) {
+          options.add(option);
+        }
+      }
+    }
+
     return switch (functionName.toLowerCase()) {
-      case "swgenesys", "genesys" -> performRoll(functionName, resolver, parameters);
-      case "swgenesyslastdetails", "genesyslastdetails" -> returnDetails(
-          functionName.toLowerCase().replace("lastdetails", ""), resolver);
-      case "swgenesyslastrolls", "genesyslastrolls" -> renderRolls(
-          functionName.toLowerCase().replace("lastrolls", ""), resolver);
-      case "swgenesyslastgrouped", "genesyslastgrouped" -> renderGrouped(
-          functionName.toLowerCase().replace("lastgrouped", ""), resolver);
+      case "swgenesys", "genesys" -> performRoll(functionName, resolver, parameters, options);
+      case "swgenesyslast", "genesyslast" -> render(
+          functionName.toLowerCase().replace("last", ""), resolver, options);
       default -> // Should never happen
       throw new ParserException("Invalid function name: " + functionName);
     };
   }
 
+  /**
+   * Render the results of the roll string saved in the variables.
+   *
+   * @param functionName the name of the function.
+   * @param resolver the variable resolver.
+   * @param options the options for the roll.
+   * @return the rendered results.
+   * @throws ParserException if an error occurs.
+   */
+  private Object render(String functionName, VariableResolver resolver, Set<Options> options)
+      throws ParserException {
+    if (options.contains(Options.FORMAT_JSON)) {
+      return returnDetails(functionName, resolver);
+    } else if (options.contains(Options.FORMAT_GROUP_DICE)) {
+      return renderGrouped(functionName, resolver, options);
+    } else {
+      return renderRolls(functionName, resolver, options);
+    }
+  }
+
   /**
    * Render the results of a roll.
    *
    * @param functionName the name of the function.
    * @param resolver the variable resolver.
+   * @param options the options for the roll.
    * @return the rendered results.
    * @throws ParserException if an error occurs.
    */
-  private String renderGrouped(String functionName, VariableResolver resolver)
+  private String renderGrouped(String functionName, VariableResolver resolver, Set<Options> options)
       throws ParserException {
     var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
     var rollsMap = new HashMap<String, List<String>>();
@@ -432,20 +493,36 @@ private String renderGrouped(String functionName, VariableResolver resolver)
               .toList();
       rollsMap.put(dieName, rolls);
     }
-    return renderGrouped(functionName, rollsMap);
+    return renderGrouped(
+        functionName, rollResults.get("diceString").getAsString(), rollsMap, options);
   }
 
   /**
    * Render the results of a roll to a string.
    *
    * @param functionName the name of the function.
+   * @param diceString the string representing the dice rolled.
    * @param rolls the rolls to render.
+   * @param options the options for the roll.
    * @return the rendered results.
    */
-  private String renderGrouped(String functionName, Map<String, List<String>> rolls) {
+  private String renderGrouped(
+      String functionName,
+      String diceString,
+      Map<String, List<String>> rolls,
+      Set<Options> options) {
     var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
     var sb = new StringBuilder();
+
+    // We don't want to pass the expanded format option to the renderRolls method as we deal with
+    // it here.
+    var passedOptions = new HashSet<>(options);
+    passedOptions.remove(Options.EXPANDED_FORMAT);
+
     sb.append("<span style='color:").append(gray).append("'>");
+    if (options.contains(Options.EXPANDED_FORMAT)) {
+      sb.append(diceString).append(" = ");
+    }
     var dieTypes =
         Arrays.stream(DiceType.values())
             .sorted(Comparator.comparingInt(DiceType::getGroupSort))
@@ -461,10 +538,10 @@ private String renderGrouped(String functionName, Map<String, List<String>> roll
         sb.append(dieName).append(": ");
         var dieRolls =
             rolls.get(dieName).stream().map(r -> ResultType.valueOf(r.toUpperCase())).toList();
-        sb.append(renderRolls(functionName, dieRolls));
+        sb.append(renderRolls(functionName, diceString, dieRolls, passedOptions));
       }
-      sb.append("</span>");
     }
+    sb.append("</span>");
     return sb.toString();
   }
 
@@ -473,10 +550,11 @@ private String renderGrouped(String functionName, Map<String, List<String>> roll
    *
    * @param functionName the name of the function.
    * @param resolver the variable resolver.
+   * @param options the options for the roll.
    * @return the rendered results.
    * @throws ParserException if an error occurs.
    */
-  private String renderRolls(String functionName, VariableResolver resolver)
+  private String renderRolls(String functionName, VariableResolver resolver, Set<Options> options)
       throws ParserException {
     var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
     var rolls =
@@ -490,7 +568,7 @@ private String renderRolls(String functionName, VariableResolver resolver)
                 false)
             .map(r -> ResultType.valueOf(r.getAsString().toUpperCase()))
             .toList();
-    return renderRolls(functionName, rolls);
+    return renderRolls(functionName, rollResults.get("diceString").getAsString(), rolls, options);
   }
 
   /**
@@ -512,11 +590,12 @@ private JsonObject returnDetails(String functionName, VariableResolver resolver)
    * @param functionName the name of the function.
    * @param resolver the variable resolver.
    * @param parameters the parameters to the function.
+   * @param options the options for the roll.
    * @return the rendered results.
    * @throws ParserException if an error occurs.
    */
-  private String performRoll(
-      String functionName, VariableResolver resolver, List<Object> parameters)
+  private Object performRoll(
+      String functionName, VariableResolver resolver, List<Object> parameters, Set<Options> options)
       throws ParserException {
 
     var diceString = parameters.get(0).toString().toLowerCase();
@@ -599,32 +678,77 @@ private String performRoll(
     gson.add("rolls", new Gson().toJsonTree(individualResults).getAsJsonObject());
     gson.add("counters", new Gson().toJsonTree(counters).getAsJsonObject());
     gson.add("result", new Gson().toJsonTree(result).getAsJsonObject());
+    gson.addProperty("diceString", diceString);
 
     resolver.setVariable(ROLL_VARIABLE_MAP.get(functionName), gson);
 
-    return renderRolls(functionName, results);
+    if (options.contains(Options.FORMAT_JSON)) {
+      return returnDetails(functionName, resolver);
+    } else if (options.contains(Options.FORMAT_GROUP_DICE)) {
+      return renderGrouped(functionName, diceString, individualResults, options);
+    } else {
+      return renderRolls(functionName, diceString, results, options);
+    }
   }
 
   /**
    * Render the results of a roll to a string.
    *
    * @param functionName the name of the function.
+   * @param diceString the string representing the dice rolled.
    * @param results the results to render.
+   * @param options the options for the roll.
    * @return the rendered results.
    */
-  private String renderRolls(String functionName, List<ResultType> results) {
+  private String renderRolls(
+      String functionName, String diceString, List<ResultType> results, Set<Options> options) {
     var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
 
+    List<ResultType> toDisplay = results;
+    if (options.contains(Options.FORMAT_GROUP_RESULTS)) {
+      toDisplay =
+          results.stream()
+              .map(this::explode)
+              .flatMap(List::stream)
+              .filter(rt -> rt != ResultType.NONE)
+              .sorted(Comparator.comparingInt(ResultType::getGroupSort))
+              .toList();
+    }
     var sb = new StringBuilder();
+    sb.append("<span style='color:").append(gray).append("'>");
+    if (options.contains(Options.EXPANDED_FORMAT)) {
+      sb.append(diceString).append(" = ");
+    }
     sb.append("<font face='")
         .append(GS_FONT_NAME_MAP.get(functionName))
         .append("' size ='+1' color='")
         .append(gray)
         .append("'>");
-    for (var result : results) {
+    for (var result : toDisplay) {
       sb.append(result.fontCharacters);
     }
     sb.append("</font>");
+    sb.append("</span>");
     return sb.toString();
   }
+
+  /**
+   * Explode the result type by expanding doubles to their component parts.`
+   *
+   * @param resultType the result type to simplify.
+   * @return the exploded result type.
+   */
+  private List<ResultType> explode(ResultType resultType) {
+    return switch (resultType) {
+      case SUCCESS_ADVANTAGE -> List.of(ResultType.SUCCESS, ResultType.ADVANTAGE);
+      case ADVANTAGE_ADVANTAGE -> List.of(ResultType.ADVANTAGE, ResultType.ADVANTAGE);
+      case SUCCESS_SUCCESS -> List.of(ResultType.SUCCESS, ResultType.SUCCESS);
+      case FAILURE_THREAT -> List.of(ResultType.FAILURE, ResultType.THREAT);
+      case FAILURE_FAILURE -> List.of(ResultType.FAILURE, ResultType.FAILURE);
+      case THREAT_THREAT -> List.of(ResultType.THREAT, ResultType.THREAT);
+      case LIGHT_LIGHT -> List.of(ResultType.LIGHT, ResultType.LIGHT);
+      case DARK_DARK -> List.of(ResultType.DARK, ResultType.DARK);
+      default -> List.of(resultType);
+    };
+  }
 }

From 0c7991869c921a19ef3fda2fd1f20abf9bda8a39 Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Sat, 23 Sep 2023 22:31:32 +0930
Subject: [PATCH 4/6] add lib for advanced rolls

---
 build.gradle | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/build.gradle b/build.gradle
index 170458b472..621951a279 100644
--- a/build.gradle
+++ b/build.gradle
@@ -496,6 +496,14 @@ dependencies {
 
     implementation 'com.github.jknack:handlebars:4.3.1'
     implementation 'com.github.jknack:handlebars-helpers:4.3.1'
+
+    // For advanced dice roller
+    implementation 'com.github.RPTools:advanced-dice-roller:0.1.4'
+
+
+
+
+
 }
 
 

From 8356de8f79b945de21d4bf05ec6cd011a16ba21f Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Fri, 29 Sep 2023 19:39:21 +0930
Subject: [PATCH 5/6] add roll types

---
 build.gradle                                  |   2 +-
 .../dicelib/expression/ExpressionParser.java  |  41 ++-
 .../function/advanced/AdvancedDiceRolls.java  |  51 ++++
 .../function/advanced/GenesysDiceRolls.java   | 261 ++++++++++++++++++
 .../client/MapToolVariableResolver.java       |   2 +-
 .../rptools/maptool/language/i18n.properties  |  12 +-
 6 files changed, 354 insertions(+), 15 deletions(-)
 create mode 100644 src/main/java/net/rptools/dicelib/expression/function/advanced/AdvancedDiceRolls.java
 create mode 100644 src/main/java/net/rptools/dicelib/expression/function/advanced/GenesysDiceRolls.java

diff --git a/build.gradle b/build.gradle
index 621951a279..f504291dd4 100644
--- a/build.gradle
+++ b/build.gradle
@@ -498,7 +498,7 @@ dependencies {
     implementation 'com.github.jknack:handlebars-helpers:4.3.1'
 
     // For advanced dice roller
-    implementation 'com.github.RPTools:advanced-dice-roller:0.1.4'
+    implementation 'com.github.RPTools:advanced-dice-roller:1.0.3'
 
 
 
diff --git a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
index 84f45dc425..33ad23b422 100755
--- a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
+++ b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
@@ -14,6 +14,8 @@
  */
 package net.rptools.dicelib.expression;
 
+import java.util.List;
+import java.util.regex.Pattern;
 import net.rptools.dicelib.expression.function.ArsMagicaStress;
 import net.rptools.dicelib.expression.function.CountSuccessDice;
 import net.rptools.dicelib.expression.function.DropHighestRoll;
@@ -37,9 +39,11 @@
 import net.rptools.dicelib.expression.function.ShadowRun5Dice;
 import net.rptools.dicelib.expression.function.ShadowRun5ExplodeDice;
 import net.rptools.dicelib.expression.function.UbiquityRoll;
+import net.rptools.dicelib.expression.function.advanced.AdvancedDiceRolls;
 import net.rptools.parser.*;
 import net.rptools.parser.transform.RegexpStringTransformer;
 import net.rptools.parser.transform.StringLiteralTransformer;
+import org.javatuples.Pair;
 
 public class ExpressionParser {
   private static String[][] DICE_PATTERNS =
@@ -206,22 +210,15 @@ public class ExpressionParser {
         new String[] {"\\b[aA][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStress($1, $2)"},
         new String[] {"\\b[aA][nN][sS](\\d+)\\b", "arsMagicaStressNum($1, 0)"},
         new String[] {"\\b[aA][nN][sS](\\d+)[bB]#([+-]?\\d+)\\b", "arsMagicaStressNum($1, $2)"},
-
-        // SW Genesys
-        new String[] {
-          "\\bsw#(([bBsSaAdDpPcCfF]\\d+)+)(\\.(([eEgGdDjJ])+))?\\b", "swgenesys('$1', '$4')"
-        },
-        new String[] {"\\bsw#last(\\.(([eEgGdDjJ])+))*\\b", "swgenesysLast('last', '$2')"},
-
-        // Genesys
-        new String[] {
-          "\\bgs#(([bBsSaAdDpPcCjJ]\\d+)+)(\\.(([eEgGdD])+))?\\b", "genesys('$1', " + "'$4')"
-        },
-        new String[] {"\\bgs#last(\\.(([eEgGdDj])+))*\\b", "genesysLast('last', '$2')"}
       };
 
   private final Parser parser;
 
+  private final List<Pair<Pattern, String>> preprocessPatterns =
+      List.of(
+          new Pair<>(Pattern.compile("([A-z]+)!\"([^\"]*)\""), "advancedRoll('$1', " + "'$2')"),
+          new Pair<>(Pattern.compile("([A-z]+)!'([^']*)'"), "advancedRoll('$1', " + "'$2')"));
+
   public ExpressionParser() {
     this(DICE_PATTERNS);
   }
@@ -252,6 +249,7 @@ public ExpressionParser(String[][] regexpTransforms) {
     parser.addFunction(new KeepLowestRoll());
     parser.addFunction(new ArsMagicaStress());
     parser.addFunction(new GeneSysDice());
+    parser.addFunction(new AdvancedDiceRolls());
 
     parser.addFunction(new If());
 
@@ -291,6 +289,9 @@ public Result evaluate(String expression, VariableResolver resolver, boolean mak
       }
       RunData.setCurrent(newRunData);
 
+      // Some patterns need pre-processing before the parser is called otherwise the parser
+      // creation will fail
+      expression = preProcess(expression);
       synchronized (parser) {
         final Expression xp =
             makeDeterministic
@@ -306,4 +307,20 @@ public Result evaluate(String expression, VariableResolver resolver, boolean mak
 
     return ret;
   }
+
+  /**
+   * Pre-process the expression before it is parsed. This is used to convert some patterns into
+   * function calls that the parser can handle.
+   *
+   * @param expression The expression to pre-process
+   * @return The pre-processed expression
+   */
+  private String preProcess(String expression) {
+    for (Pair<Pattern, String> p : preprocessPatterns) {
+      if (p.getValue0().matcher(expression).find()) {
+        return p.getValue0().matcher(expression).replaceAll(p.getValue1());
+      }
+    }
+    return expression;
+  }
 }
diff --git a/src/main/java/net/rptools/dicelib/expression/function/advanced/AdvancedDiceRolls.java b/src/main/java/net/rptools/dicelib/expression/function/advanced/AdvancedDiceRolls.java
new file mode 100644
index 0000000000..b1acc165dd
--- /dev/null
+++ b/src/main/java/net/rptools/dicelib/expression/function/advanced/AdvancedDiceRolls.java
@@ -0,0 +1,51 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.dicelib.expression.function.advanced;
+
+import java.util.List;
+import net.rptools.dicelib.expression.function.advanced.GenesysDiceRolls.DiceType;
+import net.rptools.maptool.language.I18N;
+import net.rptools.parser.Parser;
+import net.rptools.parser.ParserException;
+import net.rptools.parser.VariableResolver;
+import net.rptools.parser.function.AbstractFunction;
+
+/** Function to roll dice using the advanced dice roller. */
+public class AdvancedDiceRolls extends AbstractFunction {
+
+  /** Constructor. */
+  public AdvancedDiceRolls() {
+    super(2, 2, false, "advancedRoll");
+  }
+
+  @Override
+  public Object childEvaluate(
+      Parser parser, VariableResolver resolver, String functionName, List<Object> parameters)
+      throws ParserException {
+    String diceName = parameters.get(0).toString().toLowerCase();
+    String diceExpression = parameters.get(1).toString();
+
+    try {
+      return switch (diceName) {
+        case "sw" -> new GenesysDiceRolls().roll(DiceType.StarWars, diceExpression, resolver);
+        case "gs" -> new GenesysDiceRolls().roll(DiceType.Genesys, diceExpression, resolver);
+        default -> throw new ParserException(
+            I18N.getText("advanced.roll.unknownDiceType", diceName));
+      };
+    } catch (IllegalArgumentException e) {
+      throw new ParserException(e.getMessage());
+    }
+  }
+}
diff --git a/src/main/java/net/rptools/dicelib/expression/function/advanced/GenesysDiceRolls.java b/src/main/java/net/rptools/dicelib/expression/function/advanced/GenesysDiceRolls.java
new file mode 100644
index 0000000000..f267147026
--- /dev/null
+++ b/src/main/java/net/rptools/dicelib/expression/function/advanced/GenesysDiceRolls.java
@@ -0,0 +1,261 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.dicelib.expression.function.advanced;
+
+import java.util.Map;
+import javax.swing.JOptionPane;
+import net.rptools.maptool.advanceddice.genesys.GenesysDiceResult;
+import net.rptools.maptool.advanceddice.genesys.GenesysDiceRoller;
+import net.rptools.maptool.client.MapTool;
+import net.rptools.maptool.client.MapToolVariableResolver;
+import net.rptools.maptool.client.ui.theme.ThemeSupport;
+import net.rptools.maptool.client.ui.theme.ThemeSupport.ThemeColor;
+import net.rptools.maptool.language.I18N;
+import net.rptools.parser.ParserException;
+import net.rptools.parser.VariableResolver;
+
+/** Function to roll dice using the advanced dice roller. */
+public class GenesysDiceRolls {
+
+  /** Enum to represent the different dice types. */
+  public enum DiceType {
+    StarWars("sw"),
+    Genesys("gs");
+
+    /** The variable prefix for the dice type. */
+    public final String variablePrefix;
+
+    /**
+     * Constructor.
+     *
+     * @param variablePrefix the prefix to use for variables.
+     */
+    DiceType(String variablePrefix) {
+      this.variablePrefix = variablePrefix;
+    }
+
+    /**
+     * Get the variable prefix for the dice type.
+     *
+     * @return the variable prefix.
+     */
+    public String getVariablePrefix() {
+      return variablePrefix;
+    }
+  }
+
+  /** Map of font names for the different systems. */
+  private static final Map<DiceType, String> GS_FONT_NAME_MAP =
+      Map.of(DiceType.StarWars, "EotE Symbol", DiceType.Genesys, "Genesys Glyphs and Dice");
+
+  /**
+   * Roll the given dice string using genesys/starwars dice roll parser.
+   *
+   * @param diceType the type of dice to roll.
+   * @param diceExpression the expression to roll.
+   * @param resolver the variable resolver.
+   * @return the result of the roll.
+   * @throws ParserException if there is an error parsing the expression.
+   */
+  Object roll(DiceType diceType, String diceExpression, VariableResolver resolver)
+      throws ParserException {
+    var roller = new GenesysDiceRoller();
+    try {
+      var result =
+          roller.roll(
+              diceExpression,
+              n -> getVariable(resolver, n),
+              n -> getProperty(resolver, n),
+              n -> getPromptedValue(resolver, n));
+
+      if (result.hasErrors()) {
+        var errorSb = new StringBuilder();
+        for (var error : result.getErrors()) {
+          String msg;
+          int ind = error.charPositionInLine();
+          if (result.getRollString().length() > ind + 3) {
+            msg = result.getRollString().substring(ind, ind + 3) + "...";
+          } else {
+            msg = result.getRollString().substring(ind);
+          }
+          var errorText = I18N.getText("advanced.roll.parserError", error.line(), ind + 1, msg);
+          errorSb.append(errorText).append("<br/>");
+        }
+        throw new ParserException(errorSb.toString());
+      }
+      var varPrefix = diceType.getVariablePrefix() + ".lastRoll";
+      setVars(resolver, varPrefix, result);
+
+      return formatResults(diceType, result);
+
+    } catch (IllegalArgumentException e) {
+      throw new ParserException(e.getMessage());
+    }
+  }
+
+  /**
+   * Format the results of the roll.
+   *
+   * @param diceType the type of dice.
+   * @param result the result of the roll.
+   * @return the formatted results.
+   */
+  private String formatResults(DiceType diceType, GenesysDiceResult result) {
+    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
+
+    var sb = new StringBuilder();
+    sb.append("<span>");
+    sb.append("<font face='")
+        .append(GS_FONT_NAME_MAP.get(diceType))
+        .append("' size ='+1'")
+        .append("'>");
+    for (var dice : result.getRolls()) {
+      sb.append(dice.resultType().getFontCharacters());
+    }
+    sb.append("</font>");
+    sb.append("</span>");
+    return sb.toString();
+  }
+
+  /**
+   * Set the variables for the result.
+   *
+   * @param resolver the variable resolver.
+   * @param varPrefix the variable prefix.
+   * @param result the result.
+   * @throws ParserException if there is an error setting the variables.
+   */
+  private void setVars(VariableResolver resolver, String varPrefix, GenesysDiceResult result)
+      throws ParserException {
+    resolver.setVariable(varPrefix + ".expression", result.getRollString());
+    resolver.setVariable(varPrefix + ".success", result.getSuccessCount());
+    resolver.setVariable(varPrefix + ".failure", result.getFailureCount());
+    resolver.setVariable(varPrefix + ".advantage", result.getAdvantageCount());
+    resolver.setVariable(varPrefix + ".threat", result.getThreatCount());
+    resolver.setVariable(varPrefix + ".triumph", result.getTriumphCount());
+    resolver.setVariable(varPrefix + ".despair", result.getDespairCount());
+    resolver.setVariable(varPrefix + ".light", result.getLightCount());
+    resolver.setVariable(varPrefix + ".dark", result.getDarkCount());
+
+    for (var group : result.getGroupNames()) {
+      var groupResult = result.getGroup(group);
+      setVars(resolver, varPrefix + ".group." + group, groupResult);
+    }
+  }
+
+  /**
+   * Get the variable value.
+   *
+   * @param resolver the variable resolver.
+   * @param name the name of the variable.
+   * @return the value of the variable.
+   */
+  private int getVariable(VariableResolver resolver, String name) {
+    if (!resolver.getVariables().contains(name.toLowerCase())) {
+      throw new IllegalArgumentException(I18N.getText("advanced.roll.unknownVariable", name));
+    }
+
+    try {
+      var value = resolver.getVariable(name);
+      var result = integerResult(value, false);
+
+      if (result == null) {
+        throw new IllegalArgumentException(I18N.getText("advanced.roll.variableNotNumber", name));
+      }
+
+      return result;
+    } catch (ParserException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+
+  /**
+   * Get the property value for the token in context.
+   *
+   * @param resolver the variable resolver.
+   * @param name the name of the property.
+   * @return the value of the property.
+   */
+  private int getProperty(VariableResolver resolver, String name) {
+    var mtResolver = (MapToolVariableResolver) resolver;
+    var token = mtResolver.getTokenInContext();
+    if (token == null) {
+      throw new IllegalArgumentException(I18N.getText("advanced.roll.noTokenInContext"));
+    }
+    var value = token.getProperty(name);
+
+    if (value == null) {
+      throw new IllegalArgumentException(I18N.getText("advanced.roll.unknownProperty", name));
+    }
+
+    var result = integerResult(value, true);
+    if (result == null) {
+      throw new IllegalArgumentException(I18N.getText("advanced.roll.propertyNotNumber", name));
+    }
+
+    return result;
+  }
+
+  /**
+   * Prompt the user for a value.
+   *
+   * @param resolver the variable resolver.
+   * @param name the name of the value.
+   * @return the value.
+   */
+  private int getPromptedValue(VariableResolver resolver, String name) {
+    var option =
+        JOptionPane.showInputDialog(
+            MapTool.getFrame(),
+            I18N.getText("lineParser.dialogValueFor", name),
+            I18N.getText("lineParser.dialogTitleNoToken"),
+            JOptionPane.QUESTION_MESSAGE,
+            null,
+            null,
+            1);
+    try {
+      return Integer.parseInt(option.toString());
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException(I18N.getText("advanced.roll.inputNotNumber", name));
+    }
+  }
+
+  /**
+   * Get the integer result.
+   *
+   * @param value the value.
+   * @param parseString attempt to parse string value of object if it is not a number.
+   * @return the integer result.
+   */
+  private Integer integerResult(Object value, boolean parseString) {
+    if (value instanceof Integer i) {
+      return i;
+    }
+
+    if (value instanceof Number n) {
+      return n.intValue();
+    }
+
+    if (parseString) {
+      try {
+        return Integer.parseInt(value.toString());
+      } catch (NumberFormatException e) {
+        return null;
+      }
+    }
+
+    return null;
+  }
+}
diff --git a/src/main/java/net/rptools/maptool/client/MapToolVariableResolver.java b/src/main/java/net/rptools/maptool/client/MapToolVariableResolver.java
index f1489caf77..ed31fbcccb 100644
--- a/src/main/java/net/rptools/maptool/client/MapToolVariableResolver.java
+++ b/src/main/java/net/rptools/maptool/client/MapToolVariableResolver.java
@@ -276,7 +276,7 @@ public Object getVariable(String name, VariableModifiers mods) throws ParserExce
       result =
           JOptionPane.showInputDialog(
               MapTool.getFrame(),
-              I18N.getText("lineParser.dialogValueFor") + " " + name,
+              I18N.getText("lineParser.dialogValueFor", name),
               DialogTitle,
               JOptionPane.QUESTION_MESSAGE,
               null,
diff --git a/src/main/resources/net/rptools/maptool/language/i18n.properties b/src/main/resources/net/rptools/maptool/language/i18n.properties
index 2d7975a06f..9da807e8fb 100644
--- a/src/main/resources/net/rptools/maptool/language/i18n.properties
+++ b/src/main/resources/net/rptools/maptool/language/i18n.properties
@@ -1654,7 +1654,7 @@ lineParser.countNonNeg              = Count option requires a non negative numbe
 # Notice there are no double quotes around {0}.
 lineParser.dialogTitle              = Input Value for {0}.
 lineParser.dialogTitleNoToken       = Input Value.
-lineParser.dialogValueFor           = Value For
+lineParser.dialogValueFor           = Value For "{0}" 
 lineParser.duplicateLibTokens       = Duplicate "{0}" tokens found.
 lineParser.emptyTokenName           = Cannot assign a blank or empty string to the variable <i>token.name</i>
 lineParser.errorBodyRoll            = Error in body of roll.
@@ -2808,3 +2808,13 @@ Label.label=Label:
 # StatSheet
 token.statSheet.legacyStatSheetDescription = Legacy (pre 1.14) Stat Sheet
 token.statSheet.useDefault                 = Default Stat Sheet for Property Type
+
+# Advanced Dice Rolls
+advanced.roll.parserError                  = Dice Roll String Error line {0} column {1} "{2}".
+advanced.roll.unknownDiceType              = Unknown Dice Roll Type {0}.
+advanced.roll.unknownVariable              = Unknown Variable {0}.
+advanced.roll.variableNotNumber            = Variable {0} is not a number.
+advanced.roll.unknownProperty              = Unknown Property {0}.
+advanced.roll.propertyNotNumber            = Property {0} is not a number.
+advanced.roll.noTokenInContext             = No token in context.
+advanced.roll.inputNotNumber               = Input {0} is not a number.
\ No newline at end of file

From 3ff483409e46447c0aea4507dedeb5c428fa3085 Mon Sep 17 00:00:00 2001
From: cwisniew <craig.wisniewski@gmail.com>
Date: Fri, 29 Sep 2023 20:06:17 +0930
Subject: [PATCH 6/6] remove redundant code

---
 .../dicelib/expression/ExpressionParser.java  |   2 -
 .../expression/function/GeneSysDice.java      | 754 ------------------
 2 files changed, 756 deletions(-)
 delete mode 100644 src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java

diff --git a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
index 33ad23b422..1653aa10d3 100755
--- a/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
+++ b/src/main/java/net/rptools/dicelib/expression/ExpressionParser.java
@@ -23,7 +23,6 @@
 import net.rptools.dicelib.expression.function.ExplodeDice;
 import net.rptools.dicelib.expression.function.ExplodingSuccessDice;
 import net.rptools.dicelib.expression.function.FudgeRoll;
-import net.rptools.dicelib.expression.function.GeneSysDice;
 import net.rptools.dicelib.expression.function.HeroKillingRoll;
 import net.rptools.dicelib.expression.function.HeroRoll;
 import net.rptools.dicelib.expression.function.If;
@@ -248,7 +247,6 @@ public ExpressionParser(String[][] regexpTransforms) {
     parser.addFunction(new DropHighestRoll());
     parser.addFunction(new KeepLowestRoll());
     parser.addFunction(new ArsMagicaStress());
-    parser.addFunction(new GeneSysDice());
     parser.addFunction(new AdvancedDiceRolls());
 
     parser.addFunction(new If());
diff --git a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java b/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
deleted file mode 100644
index 0283dd085b..0000000000
--- a/src/main/java/net/rptools/dicelib/expression/function/GeneSysDice.java
+++ /dev/null
@@ -1,754 +0,0 @@
-/*
- * This software Copyright by the RPTools.net development team, and
- * licensed under the Affero GPL Version 3 or, at your option, any later
- * version.
- *
- * MapTool Source Code is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public
- * License * along with this source Code.  If not, please visit
- * <http://www.gnu.org/licenses/> and specifically the Affero license
- * text at <http://www.gnu.org/licenses/agpl.html>.
- */
-package net.rptools.dicelib.expression.function;
-
-import com.google.gson.Gson;
-import com.google.gson.JsonObject;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-import java.util.stream.StreamSupport;
-import net.rptools.maptool.client.ui.theme.ThemeSupport;
-import net.rptools.maptool.client.ui.theme.ThemeSupport.ThemeColor;
-import net.rptools.parser.Parser;
-import net.rptools.parser.ParserException;
-import net.rptools.parser.VariableResolver;
-import net.rptools.parser.function.AbstractFunction;
-
-/** This class implements the dice rolling functions for genesys / starwars genesys systems. */
-public class GeneSysDice extends AbstractFunction {
-
-  /** Enumeration of the possible results of a die roll. */
-  enum ResultType {
-    /** A single success. */
-    SUCCESS(1, 0, 0, 0, 0, 0, 0, 0, "s", 1),
-    /** A single failure. */
-    FAILURE(0, 1, 0, 0, 0, 0, 0, 0, "f", 2),
-    /** A single advantage. */
-    ADVANTAGE(0, 0, 1, 0, 0, 0, 0, 0, "a", 3),
-    /** A single threat. */
-    THREAT(0, 0, 0, 1, 0, 0, 0, 0, "h", 4),
-    /** A single triumph. */
-    TRIUMPH(1, 0, 0, 0, 1, 0, 0, 0, "t", 5),
-    /** A single despair. */
-    DESPAIR(0, 1, 0, 0, 0, 1, 0, 0, "d", 6),
-    /* A single light side point. */
-    LIGHT(0, 0, 0, 0, 0, 0, 1, 0, "Z", 7),
-    /** A single dark side point. */
-    DARK(0, 0, 0, 0, 0, 0, 0, 1, "z", 8),
-    /** No result. */
-    NONE(0, 0, 0, 0, 0, 0, 0, 0, " ", 99),
-    /** A single success and a single advantage. */
-    SUCCESS_ADVANTAGE(1, 0, 1, 0, 0, 0, 0, 0, "sa", 99),
-    /** Two Advantages. */
-    ADVANTAGE_ADVANTAGE(0, 0, 2, 0, 0, 0, 0, 0, "aa", 99),
-    /** Two Successes. */
-    SUCCESS_SUCCESS(2, 0, 0, 0, 0, 0, 0, 0, "ss", 99),
-    /* A single failure and a single threat. */
-    FAILURE_THREAT(0, 1, 0, 1, 0, 0, 0, 0, "fh", 99),
-    /** Two Failures. */
-    FAILURE_FAILURE(0, 2, 0, 0, 0, 0, 0, 0, "ff", 99),
-    /** Two Threats. */
-    THREAT_THREAT(0, 0, 0, 2, 0, 0, 0, 0, "hh", 99),
-    /** Two Light Side Points. */
-    LIGHT_LIGHT(0, 0, 0, 0, 0, 0, 2, 0, "ZZ", 99),
-    /** Two Dark Side Points. */
-    DARK_DARK(0, 0, 0, 0, 0, 0, 0, 2, "zz", 99);
-
-    /** The number of successes this result represents. */
-    private final int success;
-    /** The number of failures this result represents. */
-    private final int failure;
-    /** The number of advantages this result represents. */
-    private final int advantage;
-    /** The number of threats this result represents. */
-    private final int threat;
-    /** The number of triumphs this result represents. */
-    private final int triumph;
-    /** The number of despairs this result represents. */
-    private final int despair;
-    /** The number of light side points this result represents. */
-    private final int light;
-    /** The number of dark side points this result represents. */
-    private final int dark;
-
-    /** The font characters that represent this result. */
-    private final String fontCharacters;
-
-    /** The sort order of the result when grouped. */
-    private final int groupSort;
-
-    /**
-     * Constructor.
-     *
-     * @param success the number of successes this result represents.
-     * @param failure the number of failures this result represents.
-     * @param advantage the number of advantages this result represents.
-     * @param threat the number of threats this result represents.
-     * @param triumph the number of triumphs this result represents.
-     * @param despair the number of despairs this result represents.
-     * @param light the number of light side points this result represents.
-     * @param dark the number of dark side points this result represents.
-     * @param fontCharacters the font characters that represent this result.
-     * @param groupSort the sort order of the result when grouped.
-     */
-    ResultType(
-        int success,
-        int failure,
-        int advantage,
-        int threat,
-        int triumph,
-        int despair,
-        int light,
-        int dark,
-        String fontCharacters,
-        int groupSort) {
-      this.success = success;
-      this.failure = failure;
-      this.advantage = advantage;
-      this.threat = threat;
-      this.triumph = triumph;
-      this.despair = despair;
-      this.light = light;
-      this.dark = dark;
-      this.fontCharacters = fontCharacters;
-      this.groupSort = groupSort;
-    }
-
-    /**
-     * Get the number of successes this result represents.
-     *
-     * @return the number of successes this result represents.
-     */
-    public int getSuccess() {
-      return success;
-    }
-
-    /**
-     * Get the number of failures this result represents.
-     *
-     * @return the number of failures this result represents.
-     */
-    public int getFailure() {
-      return failure;
-    }
-
-    /**
-     * Get the number of advantages this result represents.
-     *
-     * @return the number of advantages this result represents.
-     */
-    public int getAdvantage() {
-      return advantage;
-    }
-
-    /**
-     * Get the number of threats this result represents.
-     *
-     * @return the number of threats this result represents.
-     */
-    public int getThreat() {
-      return threat;
-    }
-
-    /**
-     * Get the number of triumphs this result represents.
-     *
-     * @return the number of triumphs this result represents.
-     */
-    public int getTriumph() {
-      return triumph;
-    }
-
-    /**
-     * Get the number of despairs this result represents.
-     *
-     * @return the number of despairs this result represents.
-     */
-    public int getDespair() {
-      return despair;
-    }
-
-    /**
-     * Get the number of light side points this result represents.
-     *
-     * @return the number of light side points this result represents.
-     */
-    public int getLight() {
-      return light;
-    }
-
-    /**
-     * Get the number of dark side points this result represents.
-     *
-     * @return the number of dark side points this result represents.
-     */
-    public int getDark() {
-      return dark;
-    }
-
-    /**
-     * Get the font characters that represent this result.
-     *
-     * @return the font characters that represent this result.
-     */
-    public int getGroupSort() {
-      return groupSort;
-    }
-  }
-
-  /** Enumeration of the possible dice types. */
-  private enum DiceType {
-    /** The boost die. */
-    BOOST(
-        "b",
-        0,
-        List.of(
-            ResultType.NONE,
-            ResultType.NONE,
-            ResultType.SUCCESS,
-            ResultType.SUCCESS_ADVANTAGE,
-            ResultType.ADVANTAGE_ADVANTAGE,
-            ResultType.ADVANTAGE)),
-
-    /** The setback die. */
-    SETBACK(
-        "s",
-        1,
-        List.of(
-            ResultType.NONE,
-            ResultType.NONE,
-            ResultType.FAILURE,
-            ResultType.FAILURE,
-            ResultType.THREAT,
-            ResultType.THREAT)),
-    /** The ability die. */
-    ABILITY(
-        "a",
-        2,
-        List.of(
-            ResultType.NONE,
-            ResultType.SUCCESS,
-            ResultType.SUCCESS,
-            ResultType.SUCCESS_SUCCESS,
-            ResultType.ADVANTAGE,
-            ResultType.ADVANTAGE,
-            ResultType.SUCCESS_ADVANTAGE,
-            ResultType.ADVANTAGE_ADVANTAGE)),
-    /** The difficulty die. */
-    DIFFICULTY(
-        "d",
-        3,
-        List.of(
-            ResultType.NONE,
-            ResultType.FAILURE,
-            ResultType.FAILURE_FAILURE,
-            ResultType.THREAT,
-            ResultType.THREAT,
-            ResultType.THREAT,
-            ResultType.THREAT_THREAT,
-            ResultType.FAILURE_THREAT)),
-    /** The proficiency die. */
-    PROFICIENCY(
-        "p",
-        4,
-        List.of(
-            ResultType.NONE,
-            ResultType.SUCCESS,
-            ResultType.SUCCESS,
-            ResultType.SUCCESS_SUCCESS,
-            ResultType.SUCCESS_SUCCESS,
-            ResultType.ADVANTAGE,
-            ResultType.SUCCESS_ADVANTAGE,
-            ResultType.SUCCESS_ADVANTAGE,
-            ResultType.SUCCESS_ADVANTAGE,
-            ResultType.ADVANTAGE_ADVANTAGE,
-            ResultType.ADVANTAGE_ADVANTAGE,
-            ResultType.TRIUMPH)),
-    /* The challenge die. */
-    CHALLENGE(
-        "c",
-        5,
-        List.of(
-            ResultType.NONE,
-            ResultType.FAILURE,
-            ResultType.FAILURE,
-            ResultType.FAILURE_FAILURE,
-            ResultType.FAILURE_FAILURE,
-            ResultType.THREAT,
-            ResultType.THREAT,
-            ResultType.FAILURE_THREAT,
-            ResultType.FAILURE_THREAT,
-            ResultType.THREAT_THREAT,
-            ResultType.THREAT_THREAT,
-            ResultType.DESPAIR)),
-    /** The force die. */
-    FORCE(
-        "f",
-        6,
-        List.of(
-            ResultType.DARK,
-            ResultType.DARK,
-            ResultType.DARK,
-            ResultType.DARK,
-            ResultType.DARK,
-            ResultType.DARK,
-            ResultType.DARK_DARK,
-            ResultType.LIGHT,
-            ResultType.LIGHT,
-            ResultType.LIGHT_LIGHT,
-            ResultType.LIGHT_LIGHT,
-            ResultType.LIGHT_LIGHT));
-
-    /** The sides of the die. */
-    private final List<ResultType> sides;
-
-    /** The pattern used to represent this die. */
-    private final String diePattern;
-
-    /** The sort order of the die when grouped, */
-    private final int groupSort;
-
-    /**
-     * Constructor.
-     *
-     * @param diePattern the pattern used to represent this die.
-     * @param groupSort the sort order of the die when grouped.
-     * @param sides the sides of the die.
-     */
-    DiceType(String diePattern, int groupSort, List<ResultType> sides) {
-      this.sides = sides;
-      this.groupSort = groupSort;
-      this.diePattern = diePattern;
-    }
-
-    /**
-     * Get the pattern used to represent this die.
-     *
-     * @return the pattern used to represent this die.
-     */
-    public String getDiePattern() {
-      return diePattern;
-    }
-
-    /**
-     * Get the number of sides on this die.
-     *
-     * @return the number of sides on this die.
-     */
-    public int getSides() {
-      return sides.size();
-    }
-
-    /**
-     * Roll the die.
-     *
-     * @return the result of the roll.
-     */
-    public ResultType roll() {
-      return getSide(DiceHelper.rollDice(1, sides.size()) - 1);
-    }
-
-    /**
-     * Get the result of a roll of the die.
-     *
-     * @param side the side of the die to get the result for.
-     * @return the result of the roll.
-     */
-    public ResultType getSide(int side) {
-      return sides.get(side);
-    }
-
-    /**
-     * Get the sort order of the die when grouped.
-     *
-     * @return the sort order of the die when grouped.
-     */
-    public int getGroupSort() {
-      return groupSort;
-    }
-  }
-
-  /** Enumeration of the possible options for the dice roll. */
-  private enum Options {
-    /** Group the rolls by die type. */
-    FORMAT_GROUP_DICE("d"),
-    /** Group the rolls by result. */
-    FORMAT_GROUP_RESULTS("g"),
-    /** print out the rolls in expanded format. */
-    EXPANDED_FORMAT("e"),
-    /** Return the results as JSON. */
-    FORMAT_JSON("j");
-
-    /** The string used to represent this option. */
-    private final String optionString;
-
-    Options(String optionString) {
-      this.optionString = optionString;
-    }
-
-    /**
-     * Get the string used to represent this option.
-     *
-     * @return the string used to represent this option.
-     */
-    public String getOptionString() {
-      return optionString;
-    }
-  }
-
-  /** Map of font names for the different systems. */
-  private static final Map<String, String> GS_FONT_NAME_MAP =
-      Map.of("swgenesys", "EotE Symbol", "genesys", "Genesys Glyphs and Dice");
-
-  /** Map of variable names for the different systems. */
-  private static final Map<String, String> ROLL_VARIABLE_MAP =
-      Map.of("swgenesys", "#lastSWResult", "genesys", "#lastGSResult");
-
-  /** Constructor. */
-  public GeneSysDice() {
-    super(1, 2, false, "swgenesys", "genesys", "swgenesyslast", "genesyslast");
-  }
-
-  @Override
-  public Object childEvaluate(
-      Parser parser, VariableResolver resolver, String functionName, List<Object> parameters)
-      throws ParserException {
-
-    var options = new HashSet<Options>();
-    if (parameters.size() > 1) {
-      var optionsString = parameters.get(1).toString().toLowerCase();
-      for (var option : Options.values()) {
-        if (optionsString.contains(option.getOptionString())) {
-          options.add(option);
-        }
-      }
-    }
-
-    return switch (functionName.toLowerCase()) {
-      case "swgenesys", "genesys" -> performRoll(functionName, resolver, parameters, options);
-      case "swgenesyslast", "genesyslast" -> render(
-          functionName.toLowerCase().replace("last", ""), resolver, options);
-      default -> // Should never happen
-      throw new ParserException("Invalid function name: " + functionName);
-    };
-  }
-
-  /**
-   * Render the results of the roll string saved in the variables.
-   *
-   * @param functionName the name of the function.
-   * @param resolver the variable resolver.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   * @throws ParserException if an error occurs.
-   */
-  private Object render(String functionName, VariableResolver resolver, Set<Options> options)
-      throws ParserException {
-    if (options.contains(Options.FORMAT_JSON)) {
-      return returnDetails(functionName, resolver);
-    } else if (options.contains(Options.FORMAT_GROUP_DICE)) {
-      return renderGrouped(functionName, resolver, options);
-    } else {
-      return renderRolls(functionName, resolver, options);
-    }
-  }
-
-  /**
-   * Render the results of a roll.
-   *
-   * @param functionName the name of the function.
-   * @param resolver the variable resolver.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   * @throws ParserException if an error occurs.
-   */
-  private String renderGrouped(String functionName, VariableResolver resolver, Set<Options> options)
-      throws ParserException {
-    var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
-    var rollsMap = new HashMap<String, List<String>>();
-    for (var entry : rollResults.get("rolls").getAsJsonObject().entrySet()) {
-      var dieName = entry.getKey();
-      var rolls =
-          StreamSupport.stream(entry.getValue().getAsJsonArray().spliterator(), false)
-              .map(r -> r.getAsString().toLowerCase())
-              .toList();
-      rollsMap.put(dieName, rolls);
-    }
-    return renderGrouped(
-        functionName, rollResults.get("diceString").getAsString(), rollsMap, options);
-  }
-
-  /**
-   * Render the results of a roll to a string.
-   *
-   * @param functionName the name of the function.
-   * @param diceString the string representing the dice rolled.
-   * @param rolls the rolls to render.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   */
-  private String renderGrouped(
-      String functionName,
-      String diceString,
-      Map<String, List<String>> rolls,
-      Set<Options> options) {
-    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
-    var sb = new StringBuilder();
-
-    // We don't want to pass the expanded format option to the renderRolls method as we deal with
-    // it here.
-    var passedOptions = new HashSet<>(options);
-    passedOptions.remove(Options.EXPANDED_FORMAT);
-
-    sb.append("<span style='color:").append(gray).append("'>");
-    if (options.contains(Options.EXPANDED_FORMAT)) {
-      sb.append(diceString).append(" = ");
-    }
-    var dieTypes =
-        Arrays.stream(DiceType.values())
-            .sorted(Comparator.comparingInt(DiceType::getGroupSort))
-            .toList();
-    boolean first = true;
-    for (var dt : dieTypes) {
-      var dieName = dt.name().toLowerCase();
-      if (rolls.containsKey(dieName)) {
-        if (!first) {
-          sb.append(", ");
-        }
-        first = false;
-        sb.append(dieName).append(": ");
-        var dieRolls =
-            rolls.get(dieName).stream().map(r -> ResultType.valueOf(r.toUpperCase())).toList();
-        sb.append(renderRolls(functionName, diceString, dieRolls, passedOptions));
-      }
-    }
-    sb.append("</span>");
-    return sb.toString();
-  }
-
-  /**
-   * Render the results of a roll to a string.
-   *
-   * @param functionName the name of the function.
-   * @param resolver the variable resolver.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   * @throws ParserException if an error occurs.
-   */
-  private String renderRolls(String functionName, VariableResolver resolver, Set<Options> options)
-      throws ParserException {
-    var rollResults = (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
-    var rolls =
-        StreamSupport.stream(
-                rollResults
-                    .get("rolls")
-                    .getAsJsonObject()
-                    .get("all")
-                    .getAsJsonArray()
-                    .spliterator(),
-                false)
-            .map(r -> ResultType.valueOf(r.getAsString().toUpperCase()))
-            .toList();
-    return renderRolls(functionName, rollResults.get("diceString").getAsString(), rolls, options);
-  }
-
-  /**
-   * Return the details of the last roll.
-   *
-   * @param functionName the name of the function.
-   * @param resolver the variable resolver.
-   * @return the details of the last roll.
-   * @throws ParserException if an error occurs.
-   */
-  private JsonObject returnDetails(String functionName, VariableResolver resolver)
-      throws ParserException {
-    return (JsonObject) resolver.getVariable(ROLL_VARIABLE_MAP.get(functionName));
-  }
-
-  /**
-   * Perform a roll.
-   *
-   * @param functionName the name of the function.
-   * @param resolver the variable resolver.
-   * @param parameters the parameters to the function.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   * @throws ParserException if an error occurs.
-   */
-  private Object performRoll(
-      String functionName, VariableResolver resolver, List<Object> parameters, Set<Options> options)
-      throws ParserException {
-
-    var diceString = parameters.get(0).toString().toLowerCase();
-
-    var pattern = Pattern.compile("(\\S)(\\d+)");
-    var matcher = pattern.matcher(diceString);
-    var results = new ArrayList<ResultType>();
-    var individualResults = new HashMap<String, List<String>>();
-
-    while (matcher.find()) {
-      var dieType = matcher.group(1);
-      var dieCount = Integer.parseInt(matcher.group(2));
-      var die =
-          Arrays.stream(DiceType.values())
-              .filter(dt -> dt.diePattern.equalsIgnoreCase(dieType))
-              .findFirst()
-              .get();
-      for (int i = 0; i < dieCount; i++) {
-        var roll = die.roll();
-        results.add(roll);
-        var dieName = die.name().toLowerCase();
-        individualResults.putIfAbsent(dieName, new ArrayList<>());
-        individualResults.get(dieName).add(roll.name().toLowerCase());
-      }
-    }
-
-    individualResults.put("all", results.stream().map(r -> r.name().toLowerCase()).toList());
-
-    // Set variable with result
-    var resultMap = new HashMap<String, Integer>();
-    for (var result : results) {
-      var resultString = result.toString().toLowerCase();
-      resultMap.put(resultString, resultMap.getOrDefault(resultString, 0) + 1);
-    }
-
-    int successCount = 0;
-    int failureCount = 0;
-    int advantageCount = 0;
-    int threatCount = 0;
-    int triumphCount = 0;
-    int despairCount = 0;
-    int lightCount = 0;
-    int darkCount = 0;
-
-    for (var result : results) {
-      successCount += result.getSuccess();
-      failureCount += result.getFailure();
-      advantageCount += result.getAdvantage();
-      threatCount += result.getThreat();
-      triumphCount += result.getTriumph();
-      despairCount += result.getDespair();
-      lightCount += result.getLight();
-      darkCount += result.getDark();
-    }
-
-    var counters = new HashMap<String, Integer>();
-    counters.put("success", successCount);
-    counters.put("failure", failureCount);
-    counters.put("advantage", advantageCount);
-    counters.put("threat", threatCount);
-    counters.put("triumph", triumphCount);
-    counters.put("despair", despairCount);
-    if (lightCount > 0) {
-      counters.put("light", lightCount);
-    }
-    if (darkCount > 0) {
-      counters.put("dark", darkCount);
-    }
-
-    var result = new HashMap<String, Integer>();
-    result.put("success", successCount - failureCount);
-    result.put("advantage", advantageCount - threatCount);
-    result.put("triumph", triumphCount);
-    result.put("despair", despairCount);
-    if (lightCount > 0 || darkCount > 0) {
-      result.put("force", lightCount - darkCount);
-    }
-
-    var gson = new Gson().toJsonTree(resultMap).getAsJsonObject();
-    gson.add("rolls", new Gson().toJsonTree(individualResults).getAsJsonObject());
-    gson.add("counters", new Gson().toJsonTree(counters).getAsJsonObject());
-    gson.add("result", new Gson().toJsonTree(result).getAsJsonObject());
-    gson.addProperty("diceString", diceString);
-
-    resolver.setVariable(ROLL_VARIABLE_MAP.get(functionName), gson);
-
-    if (options.contains(Options.FORMAT_JSON)) {
-      return returnDetails(functionName, resolver);
-    } else if (options.contains(Options.FORMAT_GROUP_DICE)) {
-      return renderGrouped(functionName, diceString, individualResults, options);
-    } else {
-      return renderRolls(functionName, diceString, results, options);
-    }
-  }
-
-  /**
-   * Render the results of a roll to a string.
-   *
-   * @param functionName the name of the function.
-   * @param diceString the string representing the dice rolled.
-   * @param results the results to render.
-   * @param options the options for the roll.
-   * @return the rendered results.
-   */
-  private String renderRolls(
-      String functionName, String diceString, List<ResultType> results, Set<Options> options) {
-    var gray = ThemeSupport.getThemeColorHexString(ThemeColor.GREY);
-
-    List<ResultType> toDisplay = results;
-    if (options.contains(Options.FORMAT_GROUP_RESULTS)) {
-      toDisplay =
-          results.stream()
-              .map(this::explode)
-              .flatMap(List::stream)
-              .filter(rt -> rt != ResultType.NONE)
-              .sorted(Comparator.comparingInt(ResultType::getGroupSort))
-              .toList();
-    }
-    var sb = new StringBuilder();
-    sb.append("<span style='color:").append(gray).append("'>");
-    if (options.contains(Options.EXPANDED_FORMAT)) {
-      sb.append(diceString).append(" = ");
-    }
-    sb.append("<font face='")
-        .append(GS_FONT_NAME_MAP.get(functionName))
-        .append("' size ='+1' color='")
-        .append(gray)
-        .append("'>");
-    for (var result : toDisplay) {
-      sb.append(result.fontCharacters);
-    }
-    sb.append("</font>");
-    sb.append("</span>");
-    return sb.toString();
-  }
-
-  /**
-   * Explode the result type by expanding doubles to their component parts.`
-   *
-   * @param resultType the result type to simplify.
-   * @return the exploded result type.
-   */
-  private List<ResultType> explode(ResultType resultType) {
-    return switch (resultType) {
-      case SUCCESS_ADVANTAGE -> List.of(ResultType.SUCCESS, ResultType.ADVANTAGE);
-      case ADVANTAGE_ADVANTAGE -> List.of(ResultType.ADVANTAGE, ResultType.ADVANTAGE);
-      case SUCCESS_SUCCESS -> List.of(ResultType.SUCCESS, ResultType.SUCCESS);
-      case FAILURE_THREAT -> List.of(ResultType.FAILURE, ResultType.THREAT);
-      case FAILURE_FAILURE -> List.of(ResultType.FAILURE, ResultType.FAILURE);
-      case THREAT_THREAT -> List.of(ResultType.THREAT, ResultType.THREAT);
-      case LIGHT_LIGHT -> List.of(ResultType.LIGHT, ResultType.LIGHT);
-      case DARK_DARK -> List.of(ResultType.DARK, ResultType.DARK);
-      default -> List.of(resultType);
-    };
-  }
-}