feat(ui): importer carries dat justification (0x14/0x15) onto text widgets; drop character footer-title height hack

LayoutImporter.ReadState now reads Properties[0x14] (HorizontalJustification,
EnumBaseProperty: 0=Left, 1=Center, 3/5=Right) and Properties[0x15]
(VerticalJustification: 2=Top, 4=Bottom; else Center) into two new ElementInfo
fields HJustify/VJustify. Merge propagates them with the same non-default-wins
rule used for FontDid.

DatWidgetFactory.BuildText applies the resolved justify at build time:
HJustify=Center sets Centered=true, HJustify=Right sets RightAligned=true,
VJustify=Top/Bottom sets VerticalJustify. Controllers that FindElement and set
those properties afterward continue to override - backward-compat preserved.

UiText gains VerticalJustify (Top/Center/Bottom, default Center). The Centered
and RightAligned single-line paths call UiText.VOffset() for the Y coordinate,
so VJustify.Top renders text at y=Padding rather than the fixed (H-lh)/2 center.

CharacterStatController: footer title (0x1000024E, H=55 dat box) previously
used Height=18 + Anchors=None to prevent center-vertical overlap with line-1/2.
Diagnostic confirmed dat says HJustify=Center, VJustify=Center. The hack is
replaced with one minimal explicit override: VerticalJustify=Top on the
already-Centered element. Text now renders at top of the 55px box natively.
Centered=false and RightAligned=false hand-sets removed where dat supplies them.

Dat justify values (studio diagnostic, 2026-06-26):
  0x1000024E footer title: HJustify=Center, VJustify=Center
  0x10000235/0x10000243/0x10000245 value fields: HJustify=Right
  header name/heritage/pk/level: HJustify=Center

+13 tests: ElementReader Merge propagation; DatWidgetFactory BuildText
justify application + controller-override backward-compat; UiText VOffset.
696 passed, 0 failed.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

tests/AcDream.App.Tests/UI/Layout/DatWidgetFactoryTests.cs

@@ -228,4 +228,75 @@ public class DatWidgetFactoryTests
         Assert.NotEqual(OverlayFile, m.FrontRight);
         Assert.NotEqual(OverlayFile, m.FrontTile);
     }
+
+    // ── Justification build-time application (new for importer Fix A) ────────
+
+    /// <summary>
+    /// A Type-12 text element with HJustify=Center (the default) must produce a
+    /// UiText with Centered=true and RightAligned=false at build time.
+    /// This proves BuildText applies the dat's HJustify at construction without a
+    /// controller binding step.
+    /// </summary>
+    [Fact]
+    public void BuildText_HJustifyCenter_SetsCentered()
+    {
+        var info = new ElementInfo { Type = 12, Width = 100, Height = 20, HJustify = HJustify.Center };
+        var t = Assert.IsType<UiText>(DatWidgetFactory.Create(info, NoTex, null));
+        Assert.True(t.Centered);
+        Assert.False(t.RightAligned);
+        Assert.Equal(VJustify.Center, t.VerticalJustify);
+    }
+
+    /// <summary>
+    /// A Type-12 text element with HJustify=Right must produce a UiText with
+    /// Centered=false and RightAligned=true at build time.
+    /// </summary>
+    [Fact]
+    public void BuildText_HJustifyRight_SetsRightAligned()
+    {
+        var info = new ElementInfo { Type = 12, Width = 100, Height = 20, HJustify = HJustify.Right };
+        var t = Assert.IsType<UiText>(DatWidgetFactory.Create(info, NoTex, null));
+        Assert.False(t.Centered);
+        Assert.True(t.RightAligned);
+    }
+
+    /// <summary>
+    /// A Type-12 text element with HJustify=Left must produce a UiText with
+    /// Centered=false and RightAligned=false at build time.
+    /// </summary>
+    [Fact]
+    public void BuildText_HJustifyLeft_SetsNeitherCenteredNorRight()
+    {
+        var info = new ElementInfo { Type = 12, Width = 100, Height = 20, HJustify = HJustify.Left };
+        var t = Assert.IsType<UiText>(DatWidgetFactory.Create(info, NoTex, null));
+        Assert.False(t.Centered);
+        Assert.False(t.RightAligned);
+    }
+
+    /// <summary>
+    /// A Type-12 text element with VJustify=Top must produce a UiText with
+    /// VerticalJustify=Top at build time.
+    /// </summary>
+    [Fact]
+    public void BuildText_VJustifyTop_SetsVerticalJustifyTop()
+    {
+        var info = new ElementInfo { Type = 12, Width = 100, Height = 55, VJustify = VJustify.Top };
+        var t = Assert.IsType<UiText>(DatWidgetFactory.Create(info, NoTex, null));
+        Assert.Equal(VJustify.Top, t.VerticalJustify);
+    }
+
+    /// <summary>
+    /// A controller override: build-time sets Centered=true (HJustify=Center), then
+    /// a controller sets Centered=false afterward. The controller's override wins —
+    /// this is the backward-compatibility guarantee.
+    /// </summary>
+    [Fact]
+    public void BuildText_ControllerOverrideWinsAfterBuild()
+    {
+        var info = new ElementInfo { Type = 12, Width = 100, Height = 20, HJustify = HJustify.Center };
+        var t = Assert.IsType<UiText>(DatWidgetFactory.Create(info, NoTex, null));
+        Assert.True(t.Centered);   // build-time value
+        t.Centered = false;        // controller override
+        Assert.False(t.Centered);  // override wins
+    }
 }

tests/AcDream.App.Tests/UI/Layout/ElementReaderTests.cs

@@ -161,4 +161,57 @@ public class ElementReaderTests
         Assert.Single(merged.Children);
         Assert.Equal(0x2u, merged.Children[0].Id);
     }
+
+    // ── HJustify / VJustify — Merge propagation ─────────────────────────────
+
+    /// <summary>
+    /// When the derived element has a non-Center HJustify, the derived value wins
+    /// (same "non-default wins" rule as FontDid).
+    /// </summary>
+    [Fact]
+    public void Merge_DerivedHJustifyRight_OverridesBaseCenter()
+    {
+        var base_   = new ElementInfo { HJustify = HJustify.Center };
+        var derived = new ElementInfo { HJustify = HJustify.Right };
+        var merged  = ElementReader.Merge(base_, derived);
+        Assert.Equal(HJustify.Right, merged.HJustify);
+    }
+
+    /// <summary>
+    /// When the derived element has the default HJustify (Center), the base value
+    /// is inherited — Center from the derived does NOT override a Left base.
+    /// </summary>
+    [Fact]
+    public void Merge_DerivedHJustifyCenter_InheritsBaseLeft()
+    {
+        var base_   = new ElementInfo { HJustify = HJustify.Left };
+        var derived = new ElementInfo { HJustify = HJustify.Center };   // default — no explicit dat property
+        var merged  = ElementReader.Merge(base_, derived);
+        Assert.Equal(HJustify.Left, merged.HJustify);
+    }
+
+    /// <summary>
+    /// VJustify=Top from the base propagates when the derived element has no explicit
+    /// (Center) vertical justification.
+    /// </summary>
+    [Fact]
+    public void Merge_BaseVJustifyTop_InheritedWhenDerivedIsCenter()
+    {
+        var base_   = new ElementInfo { VJustify = VJustify.Top };
+        var derived = new ElementInfo { VJustify = VJustify.Center };   // default
+        var merged  = ElementReader.Merge(base_, derived);
+        Assert.Equal(VJustify.Top, merged.VJustify);
+    }
+
+    /// <summary>
+    /// VJustify=Bottom from the derived element wins over a Center base.
+    /// </summary>
+    [Fact]
+    public void Merge_DerivedVJustifyBottom_OverridesBaseCenter()
+    {
+        var base_   = new ElementInfo { VJustify = VJustify.Center };
+        var derived = new ElementInfo { VJustify = VJustify.Bottom };
+        var merged  = ElementReader.Merge(base_, derived);
+        Assert.Equal(VJustify.Bottom, merged.VJustify);
+    }
 }

tests/AcDream.App.Tests/UI/UiTextTests.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Numerics;
 using AcDream.App.UI;
+using AcDream.App.UI.Layout;
 
 namespace AcDream.App.Tests.UI;
 
@@ -140,4 +141,57 @@ public class UiTextTests
         Assert.Equal(new UiText.Pos(1, 2), s2);
         Assert.Equal(new UiText.Pos(1, 8), e2);
     }
+
+    // ── VOffset: vertical positioning for single-line mode ───────────────────
+
+    /// <summary>
+    /// VJustify.Center: vertical offset = (height - lineHeight) / 2.
+    /// This is the original formula used by both the Centered and RightAligned paths
+    /// before VerticalJustify was introduced. Must remain unchanged (backward compat).
+    /// </summary>
+    [Fact]
+    public void VOffset_Center_ReturnsHalfHeightMinusLineHeight()
+    {
+        float y = UiText.VOffset(height: 55f, lineHeight: 12f, padding: 0f, VJustify.Center);
+        Assert.Equal((55f - 12f) * 0.5f, y);
+    }
+
+    /// <summary>
+    /// VJustify.Top: vertical offset = padding (top of the content area).
+    /// Used for footer title elements whose dat box is the full footer height (55 px)
+    /// but the text should render near the top.
+    /// </summary>
+    [Fact]
+    public void VOffset_Top_ReturnsPadding()
+    {
+        float y = UiText.VOffset(height: 55f, lineHeight: 12f, padding: 0f, VJustify.Top);
+        Assert.Equal(0f, y);
+
+        float yWithPadding = UiText.VOffset(height: 55f, lineHeight: 12f, padding: 4f, VJustify.Top);
+        Assert.Equal(4f, yWithPadding);
+    }
+
+    /// <summary>
+    /// VJustify.Bottom: vertical offset = height - lineHeight - padding.
+    /// </summary>
+    [Fact]
+    public void VOffset_Bottom_ReturnsHeightMinusLineHeightMinusPadding()
+    {
+        float y = UiText.VOffset(height: 55f, lineHeight: 12f, padding: 2f, VJustify.Bottom);
+        Assert.Equal(55f - 12f - 2f, y);
+    }
+
+    /// <summary>
+    /// Center with non-zero padding: padding does NOT affect the center formula —
+    /// VJustify.Center always uses (height - lineHeight) / 2 regardless of padding,
+    /// matching the original behavior.
+    /// </summary>
+    [Fact]
+    public void VOffset_Center_IgnoresPadding()
+    {
+        float yNoPad  = UiText.VOffset(height: 40f, lineHeight: 12f, padding: 0f, VJustify.Center);
+        float yWithPad = UiText.VOffset(height: 40f, lineHeight: 12f, padding: 4f, VJustify.Center);
+        Assert.Equal(yNoPad, yWithPad);   // Center is padding-independent
+        Assert.Equal((40f - 12f) * 0.5f, yNoPad);
+    }
 }