Allow initializing text formatters without default codes and macros

CHANGELOG.md

@@ -21,6 +21,8 @@ Additions
 - Added SingleRandom and SeedSource
 - Added TokenizedString.GetArea
 - Added InputHandler.WasPressedForLess and related methods as well as InputHandler.IsPressedIgnoreRepeats
+- Added RandomExtensions.NextSingle with minimum and maximum values
+- Added subscript and superscript formatting codes
 - **Added the ability to find paths to one of multiple goals using AStar**
 
 Improvements
@@ -35,6 +37,7 @@ Improvements
 - Allow explicitly specifying each region for extended auto tiles
 - Added a generic version of IGenericDataHolder.SetData
 - Allow formatting codes to have an arbitrary custom width
+- Allow initializing text formatters without default codes and macros
 - **Drastically improved StaticSpriteBatch batching performance**
 - **Made GenericFont and TokenizedString support UTF-32 characters like emoji**
 

Demos/TextFormattingDemo.cs

@@ -18,7 +18,7 @@ namespace Demos {
             "You can write in <b>bold</i>, <i>italics</i>, <u>with an underline</u>, <st>strikethrough</st>, with a <s #000000 4>drop shadow</s> whose <s #ff0000 4>color</s> and <s #000000 10>offset</s> you can modify in each application of the code, or with various types of <b>combined <c Pink>formatting</c> codes</b>.\n\n" +
             "You can apply <c CornflowerBlue>custom</c> <c Yellow>colors</c> to text, including all default <c Orange>MonoGame colors</c> and <c #aabb00>inline custom colors</c>.\n\n" +
             "You can also use animations like <a wobbly>a wobbly one</a>, as well as create custom ones using the <a wobbly>Code class</a>.\n\n" +
-            "You can also display <i grass> icons in your text!\n\n" +
+            "You can also display <i grass> icons in your text, and use super<sup>script</sup> or sub<sub>script</sub> formatting!\n\n" +
             "Additionally, the text formatter has various methods for interacting with the text, like custom behaviors when hovering over certain parts, and more.";
         private const float Scale = 0.5F;
         private const float Width = 0.9F;

MLEM/Extensions/RandomExtensions.cs

@@ -55,5 +55,37 @@ namespace MLEM.Extensions {
             throw new IndexOutOfRangeException();
         }
 
+        /// <summary>
+        /// Returns a random floating-point number that is greater than or equal to 0, and less than <paramref name="maxValue"/>.
+        /// </summary>
+        /// <param name="random">The random.</param>
+        /// <param name="maxValue">The (exclusive) maximum value.</param>
+        /// <returns>A single-precision floating point number that is greater than or equal to 0, and less than <paramref name="maxValue"/>.</returns>
+        public static float NextSingle(this Random random, float maxValue) {
+            return maxValue * random.NextSingle();
+        }
+
+        /// <summary>
+        /// Returns a random floating-point number that is greater than or equal to <paramref name="minValue"/>, and less than <paramref name="maxValue"/>.
+        /// </summary>
+        /// <param name="random">The random.</param>
+        /// <param name="minValue">The (inclusive) minimum value.</param>
+        /// <param name="maxValue">The (exclusive) maximum value.</param>
+        /// <returns>A single-precision floating point number that is greater than or equal to <paramref name="minValue"/>, and less than <paramref name="maxValue"/>.</returns>
+        public static float NextSingle(this Random random, float minValue, float maxValue) {
+            return (maxValue - minValue) * random.NextSingle() + minValue;
+        }
+
+#if !NET6_0_OR_GREATER
+        /// <summary>
+        /// Returns a random floating-point number that is greater than or equal to 0, and less than 1.
+        /// </summary>
+        /// <param name="random">The random.</param>
+        /// <returns>A single-precision floating point number that is greater than or equal to 0, and less than 1.</returns>
+        public static float NextSingle(this Random random) {
+            return (float) random.NextDouble();
+        }
+#endif
+
     }
 }

MLEM/Formatting/Codes/SubSupCode.cs

@@ -0,0 +1,24 @@
+using System.Text.RegularExpressions;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using MLEM.Font;
+
+namespace MLEM.Formatting.Codes {
+    /// <inheritdoc />
+    public class SubSupCode : Code {
+
+        private readonly float offset;
+
+        /// <inheritdoc />
+        public SubSupCode(Match match, Regex regex, float offset) : base(match, regex) {
+            this.offset = offset;
+        }
+
+        /// <inheritdoc />
+        public override bool DrawCharacter(GameTime time, SpriteBatch batch, int codePoint, string character, Token token, int indexInToken, ref Vector2 pos, GenericFont font, ref Color color, ref float scale, float depth) {
+            pos.Y += this.offset * font.LineHeight * scale;
+            return false;
+        }
+
+    }
+}

MLEM/Formatting/TextFormatter.cs

@@ -29,10 +29,15 @@ namespace MLEM.Formatting {
         public readonly Dictionary<Regex, Macro> Macros = new Dictionary<Regex, Macro>();
 
         /// <summary>
-        /// Creates a new text formatter with a set of default formatting codes.
+        /// Creates a new text formatter with an optional set of default formatting codes.
         /// </summary>
-        public TextFormatter() {
-            // font codes
+        /// <param name="hasFontModifiers">Whether default font modifier codes should be added, including bold, italic, strikethrough, shadow, subscript, and more.</param>
+        /// <param name="hasColors">Whether default color codes should be added, including all <see cref="Color"/> values and the ability to use custom colors.</param>
+        /// <param name="hasAnimations">Whether default animation codes should be added, namely the wobbly animation.</param>
+        /// <param name="hasMacros">Whether default macros should be added, including TeX's ~ non-breaking space and more.</param>
+        public TextFormatter(bool hasFontModifiers = true, bool hasColors = true, bool hasAnimations = true, bool hasMacros = true) {
+            // general font modifier codes
+            if (hasFontModifiers) {
                 this.Codes.Add(new Regex("<b>"), (f, m, r) => new FontCode(m, r, fnt => fnt.Bold));
                 this.Codes.Add(new Regex("<i>"), (f, m, r) => new FontCode(m, r, fnt => fnt.Italic));
                 this.Codes.Add(new Regex(@"<s(?: #([0-9\w]{6,8}) (([+-.0-9]*)))?>"), (f, m, r) => new ShadowCode(m, r,
@@ -40,8 +45,14 @@ namespace MLEM.Formatting {
                     new Vector2(float.TryParse(m.Groups[2].Value, NumberStyles.Number, CultureInfo.InvariantCulture, out var offset) ? offset : 2)));
                 this.Codes.Add(new Regex("<u>"), (f, m, r) => new UnderlineCode(m, r, 1 / 16F, 0.85F));
                 this.Codes.Add(new Regex("<st>"), (f, m, r) => new UnderlineCode(m, r, 1 / 16F, 0.55F));
+                this.Codes.Add(new Regex(@"<sub(?: ([+-.0-9]+))?>"), (f, m, r) => new SubSupCode(m, r,
+                    float.TryParse(m.Groups[1].Value, NumberStyles.Number, CultureInfo.InvariantCulture, out var off) ? off : 0.15F));
+                this.Codes.Add(new Regex(@"<sup(?: ([+-.0-9]+))?>"), (f, m, r) => new SubSupCode(m, r,
+                    float.TryParse(m.Groups[1].Value, NumberStyles.Number, CultureInfo.InvariantCulture, out var off) ? -off : -0.25F));
+            }
 
             // color codes
+            if (hasColors) {
                 foreach (var c in typeof(Color).GetProperties()) {
                     if (c.GetGetMethod().IsStatic) {
                         var value = (Color) c.GetValue(null);
@@ -49,19 +60,24 @@ namespace MLEM.Formatting {
                     }
                 }
                 this.Codes.Add(new Regex(@"<c #([0-9\w]{6,8})>"), (f, m, r) => new ColorCode(m, r, ColorHelper.FromHexString(m.Groups[1].Value)));
+            }
 
             // animation codes
+            if (hasAnimations) {
                 this.Codes.Add(new Regex(@"<a wobbly(?: ([+-.0-9]*) ([+-.0-9]*))?>"), (f, m, r) => new WobblyCode(m, r,
                     float.TryParse(m.Groups[1].Value, NumberStyles.Number, CultureInfo.InvariantCulture, out var mod) ? mod : 5,
                     float.TryParse(m.Groups[2].Value, NumberStyles.Number, CultureInfo.InvariantCulture, out var heightMod) ? heightMod : 1 / 8F));
+            }
 
             // control codes
             this.Codes.Add(new Regex(@"</(\w+)>"), (f, m, r) => new SimpleEndCode(m, r, m.Groups[1].Value));
 
             // macros
+            if (hasMacros) {
                 this.Macros.Add(new Regex("~"), (f, m, r) => GenericFont.Nbsp.ToString());
                 this.Macros.Add(new Regex("<n>"), (f, m, r) => '\n'.ToString());
             }
+        }
 
         /// <summary>
         /// Tokenizes a string, returning a tokenized string that is ready for splitting, measuring and drawing.