Address review feedback and make the splash tag's colour and angle configurable

Review fixes:

- Correct a stale @PARAM on deriveSplashTagFont, which still documented
  the panelWidth parameter the method had before it was changed to take
  the logo's bounds. Flagged by CodeQL, the code-quality bot and Copilot.

- Measure the tag by the lettering actually painted rather than by the
  font's ascent and descent. Copilot was right that ascent minus descent
  underestimates the rendered height: for this font at 100pt it gives 69
  where the painted lettering of "Core Rules Edition" is 83 tall. The
  height cap was therefore letting a tag grow past the wordmark plate.
  Using ascent plus descent would swing the other way and overestimate at
  119, so both the cap and the centring now use the glyphs' visual bounds,
  which is what actually lands on the screen. The shipping tag is bound by
  width rather than height at every window size, so its appearance does
  not change; a short tag such as "BETA" is the case this was getting
  wrong.

New settings, both optional:

- splashTagColor takes the same colour names as notesColor, so the tag's
  colour is set the same way as the menu note's. Absent, or not a name
  MegaMek knows, leaves it red.

- splashTagRotation sets the angle in degrees. Zero is level, a negative
  angle drops the left-hand end and lifts the right, and a positive angle
  does the opposite. Absent leaves it at -2.5 as before, and an angle
  beyond -45 to 45 falls back to that and says so in megamek.log.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: HammerGS

megamek/resources/Version.properties

@@ -80,3 +80,18 @@ notesFontSize=14
 # and a warning goes to megamek.log.
 #
 splashTag=Core Rules Edition
+#
+# Colour of the sprayed tag, from the same list of names as notesColor above: red, orange, yellow,
+# green, blue, cyan, magenta, pink, white, black, gray, lightgray, darkgray (grey is accepted too).
+# Leave it out and the tag is sprayed in red. An unrecognised name falls back to red and is reported
+# in megamek.log. Whichever colour is chosen is left slightly see-through, so the logo shows through
+# the paint.
+#
+#splashTagColor=red
+#
+# Angle the tag is sprayed at, in degrees. Zero is level. A NEGATIVE angle drops the left-hand end and
+# lifts the right-hand end; a POSITIVE angle does the opposite. Leave it out and the tag sits at -2.5,
+# just off level, which is enough to stop it reading as a tidy caption. Anything beyond -45 to 45 is
+# treated as a mistake, falls back to -2.5, and is reported in megamek.log.
+#
+#splashTagRotation=-2.5

megamek/src/megamek/Version.java

@@ -91,6 +91,23 @@ public final class Version implements Comparable<Version>, Serializable {
     /** Key of the optional tag sprayed across the MegaMek logo on the splash art. Absent for ordinary releases. */
     private static final String SPLASH_TAG_BUNDLE_KEY = "splashTag";
 
+    /** Key of the optional colour name the splash tag is sprayed in. Absent unless a splash tag sets one. */
+    private static final String SPLASH_TAG_COLOR_BUNDLE_KEY = "splashTagColor";
+
+    /** Key of the optional angle, in degrees, the splash tag is sprayed at. Absent unless a splash tag sets one. */
+    private static final String SPLASH_TAG_ROTATION_BUNDLE_KEY = "splashTagRotation";
+
+    /** The angle the splash tag is sprayed at when it does not ask for one: very slightly off level. */
+    public static final double DEFAULT_SPLASH_TAG_ROTATION = -2.5;
+
+    /**
+     * Bounds accepted for a configured splash tag angle. Anything past this is treated as a mistake rather than
+     * an intention, since a tag turned much further than this stops reading as paint on a sign and starts
+     * running off the artwork.
+     */
+    private static final double MINIMUM_SPLASH_TAG_ROTATION = -45.0;
+    private static final double MAXIMUM_SPLASH_TAG_ROTATION = 45.0;
+
     /**
      * The value {@link #getBuildNotesFontSize()} reports when no point size is configured, meaning the build note
      * is drawn at whatever size the rest of the menu uses.
@@ -118,6 +135,8 @@ public final class Version implements Comparable<Version>, Serializable {
     private static final String BUILD_NOTES_COLOR_NAME = readOptionalEntryFromBundle(NOTES_COLOR_BUNDLE_KEY);
     private static final int BUILD_NOTES_FONT_SIZE = readOptionalNotesFontSizeFromBundle();
     private static final String SPLASH_TAG = readOptionalEntryFromBundle(SPLASH_TAG_BUNDLE_KEY);
+    private static final String SPLASH_TAG_COLOR_NAME = readOptionalEntryFromBundle(SPLASH_TAG_COLOR_BUNDLE_KEY);
+    private static final double SPLASH_TAG_ROTATION = readOptionalSplashTagRotationFromBundle();
 
     private int major;
     private int minor;
@@ -322,6 +341,36 @@ private static int readOptionalNotesFontSizeFromBundle() {
         return parsedFontSize;
     }
 
+    /**
+     * Reads the optional {@code splashTagRotation} entry from {@code Version.properties}.
+     *
+     * @return the configured angle in degrees, or {@link #DEFAULT_SPLASH_TAG_ROTATION} when the key is absent,
+     *       blank, not a number, or turned further than makes sense on the artwork
+     */
+    private static double readOptionalSplashTagRotationFromBundle() {
+        final String configuredRotation = readOptionalEntryFromBundle(SPLASH_TAG_ROTATION_BUNDLE_KEY);
+        if (configuredRotation == null) {
+            return DEFAULT_SPLASH_TAG_ROTATION;
+        }
+
+        final double parsedRotation = MathUtility.parseDouble(configuredRotation, Double.NaN);
+        final boolean isNotANumber = Double.isNaN(parsedRotation);
+        final boolean isTurnedTooFar = (parsedRotation < MINIMUM_SPLASH_TAG_ROTATION)
+              || (parsedRotation > MAXIMUM_SPLASH_TAG_ROTATION);
+        if (isNotANumber || isTurnedTooFar) {
+            LOGGER.warn("[Version] Version.properties sets splashTagRotation to '{}', which is not an angle "
+                        + "between {} and {} degrees. The splash tag will be sprayed at {} degrees instead.",
+                  configuredRotation,
+                  MINIMUM_SPLASH_TAG_ROTATION,
+                  MAXIMUM_SPLASH_TAG_ROTATION,
+                  DEFAULT_SPLASH_TAG_ROTATION);
+            return DEFAULT_SPLASH_TAG_ROTATION;
+        }
+
+        LOGGER.debug("[Version] Splash tag angle {} degrees loaded from Version.properties", parsedRotation);
+        return parsedRotation;
+    }
+
     /**
      * Reads an optional entry from {@code Version.properties}, treating an absent key and a blank value alike.
      *
@@ -423,6 +472,30 @@ public static boolean hasSplashTag() {
         return SPLASH_TAG != null;
     }
 
+    /**
+     * Returns the colour the splash tag asks to be sprayed in, as the plain name written in
+     * {@code Version.properties} rather than as a colour object, for the same reason as
+     * {@link #getBuildNotesColorName()}: this class is also used well away from the user interface.
+     *
+     * @return the configured colour name, or {@code null} when the tag did not ask for a particular colour
+     */
+    public static @Nullable String getSplashTagColorName() {
+        return SPLASH_TAG_COLOR_NAME;
+    }
+
+    /**
+     * Returns the angle, in degrees, the splash tag is sprayed at.
+     *
+     * <p>Zero is level. A negative angle drops the left-hand end and lifts the right-hand end; a positive angle
+     * does the opposite. This follows the screen's own sense of rotation, where the vertical axis points
+     * downwards.</p>
+     *
+     * @return the configured angle, or {@link #DEFAULT_SPLASH_TAG_ROTATION} when the tag did not ask for one
+     */
+    public static double getSplashTagRotation() {
+        return SPLASH_TAG_ROTATION;
+    }
+
     // region Getters
     public int getMajor() {
         return major;

megamek/src/megamek/client/ui/clientGUI/MegaMekGUI.java

@@ -42,6 +42,7 @@
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import java.awt.font.GlyphVector;
+import java.awt.geom.Rectangle2D;
 import java.awt.image.VolatileImage;
 import java.io.File;
 import java.io.FileInputStream;
@@ -164,8 +165,11 @@ public class MegaMekGUI implements IPreferenceChangeListener {
     /** Family name of the spray-paint font the splash tag is drawn in. Ships in mm-data under data/fonts. */
     private static final String SPRAY_PAINT_FONT_FAMILY = "Rubik Spray Paint";
 
-    /** Colour of the sprayed splash tag: a strong red, left see-through enough that the logo shows through it. */
-    private static final Color SPLASH_TAG_COLOR = new Color(198, 26, 26, 232);
+    /** Colour the splash tag is sprayed in when it does not name one: a strong red. */
+    private static final Color SPLASH_TAG_DEFAULT_COLOR = new Color(198, 26, 26);
+
+    /** How solid the sprayed tag is, out of 255. Short of opaque, so the logo shows through the paint. */
+    private static final int SPLASH_TAG_ALPHA = 232;
 
     /** Colour outlining the sprayed tag, which lifts the red clear of the light wordmark underneath it. */
     private static final Color SPLASH_TAG_OUTLINE_COLOR = new Color(0, 0, 0, 225);
@@ -176,9 +180,6 @@ public class MegaMekGUI implements IPreferenceChangeListener {
      */
     private static final double SPLASH_TAG_OUTLINE_WIDTH_FRACTION = 0.085;
 
-    /** How far off level the sprayed tag sits, in degrees, so it does not read as a tidy interface caption. */
-    private static final double SPLASH_TAG_TILT_DEGREES = -2.5;
-
     /** Fraction of the logo's width the sprayed tag spans, leaving it a little narrower than the logo itself. */
     private static final double SPLASH_TAG_WIDTH_FRACTION_OF_LOGO = 0.92;
 
@@ -218,6 +219,8 @@ public class MegaMekGUI implements IPreferenceChangeListener {
     private ManagedVolatileImage medalImage;
     /** Font the splash tag is sprayed in, or {@code null} when this build has no tag to spray. */
     private Font splashTagFont;
+    /** Colour the splash tag is sprayed in, worked out once when the menu is built. */
+    private Color splashTagColor = SPLASH_TAG_DEFAULT_COLOR;
     private TipOfTheDay tipOfTheDay;
     private AbstractRandomArmyDialog randomArmyDialog;
     private NetworkInformationDialog networkInformationDialog;
@@ -435,6 +438,7 @@ private void showMainMenu() {
         logoImage = new ManagedVolatileImage(getImage(FILENAME_LOGO), Transparency.TRANSLUCENT);
         medalImage = new ManagedVolatileImage(getImage(FILENAME_MEDAL), Transparency.TRANSLUCENT);
         splashTagFont = loadSplashTagFont();
+        splashTagColor = resolveSplashTagColor();
         Dimension splashPanelPreferredSize = calculateSplashPanelPreferredSize(scaledMonitorSize, splashImage);
         // This is an empty panel that will contain the splash image
         // Draw background, border, and children first
@@ -540,7 +544,7 @@ private void showMainMenu() {
      * is why {@code Version.properties} asks for a short one.</p>
      *
      * @param graphics   the graphics context the tag will be painted with, used to measure the lettering
-     * @param panelWidth the width in pixels of the splash artwork
+     * @param logoBounds the area the logo occupies, which the tag is sized against
      *
      * @return the font to spray the tag in, already at the right size, or {@code null} when this build has no tag
      */
@@ -551,11 +555,14 @@ private void showMainMenu() {
 
         String splashTag = Version.getSplashTag();
 
-        // Measure at a reference size and scale from there, which is one measurement instead of a search.
+        // Measure at a reference size and scale from there, which is one measurement instead of a search. The
+        // measurement is of the painted lettering itself rather than of the font's ascent and descent, because
+        // those describe what the font could draw rather than what this particular tag does draw.
         Font referenceFont = splashTagFont.deriveFont(SPLASH_TAG_REFERENCE_FONT_SIZE);
-        FontMetrics referenceMetrics = graphics.getFontMetrics(referenceFont);
-        int referenceWidth = referenceMetrics.stringWidth(splashTag);
-        int referenceHeight = referenceMetrics.getAscent() - referenceMetrics.getDescent();
+        Rectangle2D referenceInk = referenceFont.createGlyphVector(graphics.getFontRenderContext(), splashTag)
+              .getVisualBounds();
+        double referenceWidth = referenceInk.getWidth();
+        double referenceHeight = referenceInk.getHeight();
         if ((referenceWidth <= 0) || (referenceHeight <= 0)) {
             return null;
         }
@@ -597,28 +604,30 @@ private void drawSplashTag(Graphics2D graphics, @Nullable Rectangle logoBounds)
         }
 
         String splashTag = Version.getSplashTag();
-        FontMetrics tagMetrics = graphics.getFontMetrics(sizedSplashTagFont);
-        int tagWidth = tagMetrics.stringWidth(splashTag);
-
-        // Centred across the logo, and down it at the height the wordmark sits at
-        int tagX = logoBounds.x + ((logoBounds.width - tagWidth) / 2);
-        int lettersHeight = tagMetrics.getAscent() - tagMetrics.getDescent();
-        int wordmarkCentreY = logoBounds.y + (int) (logoBounds.height * LOGO_WORDMARK_CENTRE_FRACTION);
-        int tagY = wordmarkCentreY + (lettersHeight / 2);
 
         Graphics2D tagGraphics = (Graphics2D) graphics.create();
         try {
             tagGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
             tagGraphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                   RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-            tagGraphics.rotate(Math.toRadians(SPLASH_TAG_TILT_DEGREES),
-                  tagX + (tagWidth / 2.0),
-                  tagY - (tagMetrics.getAscent() / 2.0));
 
-            // The lettering is outlined in black and then filled in red, rather than simply drawn, so that it
-            // stands clear of the pale wordmark it is sprayed across.
+            // Measure the painted lettering, so that centring it uses where the paint actually lands rather than
+            // where the font says its tallest and lowest characters could reach.
             GlyphVector tagGlyphs = sizedSplashTagFont.createGlyphVector(tagGraphics.getFontRenderContext(),
                   splashTag);
+            Rectangle2D tagInk = tagGlyphs.getVisualBounds();
+
+            // Centred across the logo, and down it at the height the wordmark sits at
+            int tagX = logoBounds.x + (int) ((logoBounds.width - tagInk.getWidth()) / 2 - tagInk.getX());
+            int wordmarkCentreY = logoBounds.y + (int) (logoBounds.height * LOGO_WORDMARK_CENTRE_FRACTION);
+            int tagY = wordmarkCentreY - (int) (tagInk.getY() + (tagInk.getHeight() / 2));
+
+            tagGraphics.rotate(Math.toRadians(Version.getSplashTagRotation()),
+                  tagX + tagInk.getCenterX(),
+                  wordmarkCentreY);
+
+            // The lettering is outlined and then filled, rather than simply drawn, so that it stands clear of the
+            // pale wordmark it is sprayed across.
             Shape tagOutline = tagGlyphs.getOutline(tagX, tagY);
 
             float outlineWidth = (float) Math.max(1.0,
@@ -627,13 +636,40 @@ private void drawSplashTag(Graphics2D graphics, @Nullable Rectangle logoBounds)
             tagGraphics.setColor(SPLASH_TAG_OUTLINE_COLOR);
             tagGraphics.draw(tagOutline);
 
-            tagGraphics.setColor(SPLASH_TAG_COLOR);
+            tagGraphics.setColor(splashTagColor);
             tagGraphics.fill(tagOutline);
         } finally {
             tagGraphics.dispose();
         }
     }
 
+    /**
+     * Works out what colour to spray the splash tag in, the same way the build note's colour is chosen: by the
+     * plain colour name written in {@code Version.properties}.
+     *
+     * <p>A tag that names no colour, or names one that is not recognised, is sprayed in red. Whichever colour is
+     * used is left slightly see-through so the logo shows through the paint.</p>
+     *
+     * @return the colour to spray the tag in, never {@code null}
+     */
+    private static Color resolveSplashTagColor() {
+        String configuredColorName = Version.getSplashTagColorName();
+        if (configuredColorName == null) {
+            LOGGER.debug("[SplashTag] No splashTagColor set - the tag is sprayed in red");
+            return UIUtil.addAlpha(SPLASH_TAG_DEFAULT_COLOR, SPLASH_TAG_ALPHA);
+        }
+
+        Color namedColor = colorForName(configuredColorName);
+        if (namedColor == null) {
+            LOGGER.warn("[SplashTag] Version.properties sets splashTagColor to '{}', which is not a colour name "
+                        + "MegaMek knows. The tag will be sprayed in red instead.", configuredColorName);
+            return UIUtil.addAlpha(SPLASH_TAG_DEFAULT_COLOR, SPLASH_TAG_ALPHA);
+        }
+
+        LOGGER.debug("[SplashTag] Splash tag colour set to {}", configuredColorName);
+        return UIUtil.addAlpha(namedColor, SPLASH_TAG_ALPHA);
+    }
+
     /**
      * Loads the font the splash tag is sprayed in, once, when the menu is built.
      *