fix(D.5.3a): selected-object meter visual-gate fixes (name, gate, flash, magenta)
Visual gate against retail surfaced several fidelity gaps in the selected-object strip; all fixed and user-confirmed. Faithful to gmToolbarUI::HandleSelectionChanged (acclient_2013_pseudo_c.txt:198635) + RecvNotice_UpdateObjectHealth (:196213). - UiMeter.DrawHBar: guard each slice on `id != 0` BEFORE resolve. resolve(0) returns the 1x1 magenta placeholder with a non-zero GL handle, so the single- image meter (caps id=0) was drawing 1px magenta caps at the bar's ends. The 3-slice vitals meter (all ids set) was unaffected. (the magenta-lines bug) - SelectedObjectController: meter visibility is now UpdateHealth-driven (shown when health is known for the selected guid — HasHealth at select or HealthChanged), not shown-on-select; brief green selection flash via Tick revert; overlay floated above the meter so the flash isn't hidden by the bar; name top-aligned into the bar sprite's black band (NameBandHeight) with the bar below. - GameWindow.IsHealthBarTarget: gate the health bar on the server PWD bits BF_ATTACKABLE (0x10) | BF_PLAYER (0x8) — friendly/vendor NPCs and attackable Doors (Misc type) are name-only; players/monsters get the bar. Replaces the too-loose IsLiveCreatureTarget. Wired SelectedObjectController.Tick in OnUpdate. - CombatState.HasHealth(guid): distinguishes a known health value from the 1.0 default, so a re-selected already-assessed target shows its bar immediately. - TextureCache.GetOrUploadRenderSurface: resolve the surface's DefaultPaletteId so paletted (P8/INDEX16) UI sprites decode instead of falling to magenta. - ToolbarController.HiddenIds: also hide 0x100001A3 (stack-entry box) — retail hides it in HandleSelectionChanged; it was rendering as a stray black box. Divergence register: AP-47 (meter-visible timing) retired (now faithful); AP-46 rewritten to the BF_ATTACKABLE/BF_PLAYER gate approximation. Full suite green (2,688 passed / 4 skipped). User-confirmed: name on top, NPC name-only, monster bar on assess, green flash, no magenta. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik
parent
6636e50c2a
commit
8f627cce0e
8 changed files with 438 additions and 368 deletions
|
|
@ -144,8 +144,7 @@ accepted-divergence entries (#96, #49, #50).
|
|||
| AP-41 | Scrollbar thumb 3-slice cap fallback only: single-tile draw (`0x06004C63`) used only when `ThumbTopSprite`/`ThumbBotSprite` are unset; the chat controller passes all three cap ids so the 3-slice path is drawn in practice | `src/AcDream.App/UI/UiScrollbar.cs:35` | The fallback single-tile path is unreachable when caps are bound (chat controller always sets them); the 3-slice path is the active code path | Only if a future caller omits the cap ids will the fallback fire — no visual regression in the chat window | `UIElement_Scrollbar::UpdateLayout @0x4710d0`; cap sprites `0x06004C60` (top) + `0x06004C66` (bottom) from base layout `0x2100003E` |
|
||||
| AP-42 | `UiMenu` item model is flat (label + opaque payload, single-level popup); retail `UIElement_Menu::MakePopup @0x46d310` supports hierarchical nested submenus via recursive popup chain | `src/AcDream.App/UI/UiMenu.cs` | The chat talk-focus menu is single-level (14 rows, 2 columns, no submenu); hierarchy is latent and unreachable through the chat window — no behavioral difference in the current usage | A future menu with nested submenus would render flat (only the top-level items drawn, no drill-down) | `UIElement_Menu::MakePopup` @0x46d310 |
|
||||
| AP-45 | `PublicUpdatePropertyInt (0x02CE)` sequence byte parsed-past but not honored; last update wins (no freshness check against sequence number) | `src/AcDream.Core.Net/Messages/PublicUpdatePropertyInt.cs` | Loopback ACE rarely reorders; latest-wins matches `PrivateUpdateVital`/`UpdatePosition`'s existing non-sequence behavior. Sequence tracking added when needed alongside TS-26. | A reordered 0x02CE on a real network could apply a stale UiEffects value — item icon temporarily shows the wrong effect state, corrected on next update | `PublicUpdatePropertyInt` sequence byte (ACE GameMessagePublicUpdatePropertyInt) |
|
||||
| AP-46 | Health-meter gate approximation: retail shows the health meter for `IsPlayer() || pet_owner || ObjectIsAttackable()`; acdream uses `IsLiveCreatureTarget` (the `ItemType.Creature` flag) | `src/AcDream.App/UI/Layout/SelectedObjectController.cs` (`HandleSelectionChanged` analogue) | `IsLiveCreatureTarget` is already wired for Tab/Q combat-target gating and is the correct proxy for M1.5 scope (no pet system, no PK); the only practical gap is a friendly non-attackable NPC, which is rare in the ACE dev loop | A friendly (non-attackable) NPC shows a health meter where retail would show name+overlay only — false meter on non-combat NPCs | `gmToolbarUI::HandleSelectionChanged` acclient_2013_pseudo_c.txt:198754 |
|
||||
| AP-47 | Meter-visible timing: acdream shows the health meter immediately on select; retail shows it from `RecvNotice_UpdateObjectHealth` when the queried value arrives | `src/AcDream.App/UI/Layout/SelectedObjectController.cs` (`OnSelectionChanged`) | Avoids a one-round-trip blank-then-pop; the fill polls `GetHealthPercent` which returns 1.0 until the reply — visually indistinguishable for a full-HP target and self-corrects within one RTT for a damaged target | A freshly-selected off-screen-damaged target reads full for one server round-trip before the `QueryHealth` reply lands | `gmToolbarUI::HandleSelectionChanged` acclient_2013_pseudo_c.txt:198757 |
|
||||
| AP-46 | Health-meter gate approximation: retail shows the health meter for `IsPlayer() || pet_owner || ClientCombatSystem::ObjectIsAttackable()` (full PK/faction logic); acdream's `GameWindow.IsHealthBarTarget` uses the server PWD bits `BF_ATTACKABLE (0x10)` OR `BF_PLAYER (0x8)` | `src/AcDream.App/Rendering/GameWindow.cs` (`IsHealthBarTarget`) → `SelectedObjectController` | The PWD `BF_ATTACKABLE`/`BF_PLAYER` bits distinguish monsters + players (bar) from friendly/vendor NPCs (name-only) for the M1.5 dev loop; the pet case and the full ObjectIsAttackable PK/faction refinement (free-PK, PK-vs-PK, PKLite) are not ported | A PK/faction edge (e.g. a hostile-flagged player whose `BF_ATTACKABLE` is unset, or a pet) could show/hide the bar where retail differs — no impact on the non-PK PvE dev loop | `ClientCombatSystem::ObjectIsAttackable` acclient_2013_pseudo_c.txt:375385; `BF_ATTACKABLE` acclient.h:6437 |
|
||||
|
||||
---
|
||||
|
||||
|
|
|
|||
|
|
@ -2026,9 +2026,11 @@ public sealed class GameWindow : IDisposable
|
|||
_selectedObjectController = AcDream.App.UI.Layout.SelectedObjectController.Bind(
|
||||
toolbarLayout,
|
||||
subscribeSelectionChanged: h => SelectionChanged += h,
|
||||
isHealthTarget: IsLiveCreatureTarget,
|
||||
subscribeHealthChanged: h => Combat.HealthChanged += h,
|
||||
isHealthTarget: IsHealthBarTarget,
|
||||
name: g => Objects.Get(g)?.Name,
|
||||
healthPercent: g => Combat.GetHealthPercent(g),
|
||||
hasHealth: g => Combat.HasHealth(g),
|
||||
stackSize: g => (uint)(Objects.Get(g)?.StackSize ?? 0),
|
||||
sendQueryHealth: g => _liveSession?.SendQueryHealth(g),
|
||||
datFont: vitalsDatFont);
|
||||
|
|
@ -7410,6 +7412,10 @@ public sealed class GameWindow : IDisposable
|
|||
// that actually consume the events.
|
||||
_inputDispatcher?.Tick();
|
||||
|
||||
// Phase D.5.3a — advance the selected-object overlay flash (0.25s green pulse
|
||||
// on selection, then revert). No-op when nothing is flashing.
|
||||
_selectedObjectController?.Tick(dt);
|
||||
|
||||
// Phase K.2 — re-evaluate WantCaptureMouse for the MMB
|
||||
// mouse-look state machine. Detect rising/falling edges so the
|
||||
// state suspends correctly when ImGui claims the cursor while
|
||||
|
|
@ -12016,6 +12022,40 @@ public sealed class GameWindow : IDisposable
|
|||
return (LiveItemType(guid) & AcDream.Core.Items.ItemType.Creature) != 0;
|
||||
}
|
||||
|
||||
// PublicWeenieDesc _bitfield flags (acclient.h:6431-6463) — same bitfield RadarBlipColors reads.
|
||||
private const uint BfPlayer = 0x8u; // BF_PLAYER (acclient.h:6434)
|
||||
private const uint BfAttackable = 0x10u; // BF_ATTACKABLE (acclient.h:6437)
|
||||
|
||||
/// <summary>
|
||||
/// True if the selected-object strip should show a Health meter for <paramref name="guid"/>.
|
||||
/// Approximates retail's <c>IsPlayer() || pet_owner || ClientCombatSystem::ObjectIsAttackable()</c>
|
||||
/// gate (gmToolbarUI::HandleSelectionChanged :198754) using the server-provided PWD flags:
|
||||
/// the <c>BF_ATTACKABLE</c> bit (monsters) or the <c>BF_PLAYER</c> bit (other players).
|
||||
/// A friendly NPC (e.g. a vendor) has neither bit set → name-only, matching retail.
|
||||
/// The full PK/faction logic of ObjectIsAttackable + the pet case are not ported (divergence AP-46).
|
||||
/// </summary>
|
||||
private bool IsHealthBarTarget(uint guid)
|
||||
{
|
||||
if (guid == _playerServerGuid)
|
||||
return false;
|
||||
if (!_entitiesByServerGuid.ContainsKey(guid))
|
||||
return false;
|
||||
|
||||
uint pwd = _lastSpawnByGuid.TryGetValue(guid, out var spawn)
|
||||
&& spawn.ObjectDescriptionFlags is { } odf ? odf : 0u;
|
||||
|
||||
// Another player → health bar (retail IsPlayer branch).
|
||||
if ((pwd & BfPlayer) != 0)
|
||||
return true;
|
||||
|
||||
// Attackable branch: retail ObjectIsAttackable requires the object to be a CREATURE
|
||||
// first (InqType() & 0x10, acclient_2013_pseudo_c.txt:375406), THEN attackable. A Door
|
||||
// carries the BF_ATTACKABLE bit but is ItemType Misc, so it is never a health-bar target —
|
||||
// require the Creature flag here too (matches retail; excludes attackable doors/objects).
|
||||
bool isCreature = (LiveItemType(guid) & AcDream.Core.Items.ItemType.Creature) != 0;
|
||||
return isCreature && (pwd & BfAttackable) != 0;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// 2026-05-16 — retail-faithful port of
|
||||
|
|
|
|||
|
|
@ -121,9 +121,11 @@ public sealed unsafe class TextureCache : Wb.ITextureCachePerInstance, IDisposab
|
|||
/// Surface→SurfaceTexture chain that <see cref="GetOrUpload(uint)"/> uses
|
||||
/// for world-geometry materials. This is the correct path for retail UI
|
||||
/// chrome + font glyph sheets, which reference RenderSurface directly.
|
||||
/// Palette is null for now (a paletted INDEX16/P8 UI sprite would return
|
||||
/// Magenta — wire a UI palette when one is actually encountered). Returns a
|
||||
/// 1x1 magenta handle on miss.
|
||||
/// Paletted (PFID_P8 / PFID_INDEX16) UI sprites — e.g. the selected-object
|
||||
/// health-bar track 0x0600193E — are decoded against the RenderSurface's own
|
||||
/// <c>DefaultPaletteId</c> (same starting palette <see cref="DecodeFromDats"/>
|
||||
/// uses); non-paletted formats have DefaultPaletteId==0 → palette null. Returns
|
||||
/// a 1x1 magenta handle on miss.
|
||||
/// </summary>
|
||||
public uint GetOrUploadRenderSurface(uint renderSurfaceId, out int width, out int height, bool nearest = false)
|
||||
{
|
||||
|
|
@ -138,7 +140,14 @@ public sealed unsafe class TextureCache : Wb.ITextureCachePerInstance, IDisposab
|
|||
if (_dats.Portal.TryGet<RenderSurface>(renderSurfaceId, out var rs)
|
||||
|| _dats.HighRes.TryGet<RenderSurface>(renderSurfaceId, out rs))
|
||||
{
|
||||
decoded = SurfaceDecoder.DecodeRenderSurface(rs, palette: null);
|
||||
// Resolve the surface's own default palette so paletted UI sprites decode
|
||||
// correctly instead of the magenta fallback (the back-track 0x0600193E behind
|
||||
// the selected-object health bar is PFID_P8/INDEX16). Non-paletted formats
|
||||
// (DefaultPaletteId==0) keep the previous null-palette behaviour unchanged.
|
||||
Palette? palette = rs.DefaultPaletteId != 0
|
||||
? _dats.Get<Palette>(rs.DefaultPaletteId)
|
||||
: null;
|
||||
decoded = SurfaceDecoder.DecodeRenderSurface(rs, palette);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -5,74 +5,108 @@ using AcDream.App.UI;
|
|||
namespace AcDream.App.UI.Layout;
|
||||
|
||||
/// <summary>
|
||||
/// Controller for the action bar's selected-object strip (ids 0x1000019F–0x100001A1).
|
||||
/// Controller for the action bar's selected-object strip (ids 0x1000019E–0x100001A1).
|
||||
/// Analogue of retail <c>gmToolbarUI::HandleSelectionChanged</c>
|
||||
/// (<c>docs/research/named-retail/acclient_2013_pseudo_c.txt:198635</c>).
|
||||
/// (<c>docs/research/named-retail/acclient_2013_pseudo_c.txt:198635</c>) +
|
||||
/// <c>RecvNotice_UpdateObjectHealth</c> (<c>:196213</c>).
|
||||
///
|
||||
/// <para>
|
||||
/// On selection change: clears the strip (name, overlay state, health meter), then
|
||||
/// if a guid is provided it sets the name, puts the overlay field into the appropriate
|
||||
/// state ("ObjectSelected" or "StackedItemSelected"), and for health-bearing targets
|
||||
/// shows the health meter and sends a <c>QueryHealth (0x01BF)</c> request.
|
||||
/// On selection change: clears the strip (name, overlay flash, health meter), then if a
|
||||
/// guid is provided it sets the name, flashes the selection overlay briefly, and (for
|
||||
/// health-bearing targets) sends a <c>QueryHealth (0x01BF)</c> request. The Health meter
|
||||
/// becomes visible only when the server actually reports health for the selected guid —
|
||||
/// either an <c>UpdateHealth (0x01C0)</c> arrives (retail
|
||||
/// <c>RecvNotice_UpdateObjectHealth</c> → <c>SetVisible(1)</c>) or the value is already
|
||||
/// cached. So a friendly NPC you have not assessed shows name-only (no bar), and a
|
||||
/// monster's bar appears after damage / a successful assess — matching retail.
|
||||
/// </para>
|
||||
///
|
||||
/// <para>
|
||||
/// <strong>Divergence — meter-visible timing.</strong>
|
||||
/// Retail makes the health meter visible from <c>RecvNotice_UpdateObjectHealth</c>
|
||||
/// (when the queried value arrives, cite HandleSelectionChanged:198757).
|
||||
/// acdream shows it immediately on select (fill polls <see cref="CombatState.GetHealthPercent"/>
|
||||
/// which returns 1.0 until the reply lands). Recorded in the divergence register.
|
||||
/// <strong>Retail element roles</strong> (PostInit, <c>:198119</c>): <c>m_pSelObjectField</c>
|
||||
/// is the container <c>0x1000019E</c> whose <c>SetState(0x1000000b/0c)</c> drives a
|
||||
/// 0.25s <c>Pause→Normal</c> flash that cascades to the overlay child's green frame.
|
||||
/// acdream has no state-cascade / transition-animation system, so this controller drives
|
||||
/// the overlay element <c>0x100001A0</c> directly and reverts it after the same
|
||||
/// <see cref="FlashSeconds"/> to reproduce the brief flash. The name element
|
||||
/// <c>0x1000019F</c> is bumped to the top of the strip's z-order so it draws OVER the
|
||||
/// overlay frame and the health bar (retail draws the name over the bar — see the
|
||||
/// "Drudge Slinker" reference shot).
|
||||
/// </para>
|
||||
///
|
||||
/// <para>
|
||||
/// <strong>Divergence — health-target gate approximation.</strong>
|
||||
/// Retail gates on <c>IsPlayer() || pet_owner || ObjectIsAttackable()</c>
|
||||
/// (cite HandleSelectionChanged:198754). acdream uses <c>IsLiveCreatureTarget</c>
|
||||
/// (the <c>ItemType.Creature</c> flag). Recorded in the divergence register.
|
||||
/// Retail sends <c>Event_QueryHealth</c> for <c>IsPlayer() || pet_owner || ObjectIsAttackable()</c>
|
||||
/// (<c>:198754</c>). acdream uses <c>IsLiveCreatureTarget</c> (the <c>ItemType.Creature</c>
|
||||
/// flag) to gate the QueryHealth send. Visibility itself is health-data-driven (above), so
|
||||
/// the gate only affects whether we proactively query; recorded in the divergence register.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class SelectedObjectController
|
||||
{
|
||||
// ── Element ids (toolbar LayoutDesc 0x21000016) ─────────────────────────
|
||||
/// <summary>Selected-object name element id.</summary>
|
||||
/// <summary>Selected-object container / field element id (retail m_pSelObjectField).</summary>
|
||||
public const uint ContainerId = 0x1000019E;
|
||||
/// <summary>Selected-object name element id (retail m_pSelObjectName, UIElement_Text).</summary>
|
||||
public const uint NameId = 0x1000019F;
|
||||
/// <summary>Selected-object overlay field element id (states: ObjectSelected / StackedItemSelected).</summary>
|
||||
/// <summary>Selected-object overlay element id (states: ObjectSelected / StackedItemSelected).</summary>
|
||||
public const uint OverlayId = 0x100001A0;
|
||||
/// <summary>Selected-object health meter element id.</summary>
|
||||
/// <summary>Selected-object health meter element id (retail m_pSelObjectHealthMeter).</summary>
|
||||
public const uint HealthMeterId = 0x100001A1;
|
||||
|
||||
/// <summary>Selection-overlay flash duration — retail's container ObjectSelected state is a
|
||||
/// Pause(0.25s)→Normal transition (toolbar dump, element 0x1000019E).</summary>
|
||||
private const double FlashSeconds = 0.25;
|
||||
|
||||
/// <summary>Z-order for the name so it draws OVER the overlay frame + health bar.
|
||||
/// The strip's other children sit at ReadOrder 1–4; this floats the name to the top.</summary>
|
||||
private const int NameZOrderOnTop = 1_000_000;
|
||||
|
||||
/// <summary>Z-order for the selection-flash overlay — above the health meter (so the green
|
||||
/// flash isn't hidden by the bar) but below the name (so the name stays readable).</summary>
|
||||
private const int OverlayZOrder = NameZOrderOnTop - 1;
|
||||
|
||||
/// <summary>Height (px) of the black name band at the top of the 31px bar sprite. The name
|
||||
/// label is constrained to this band (top-aligned) so the health bar shows below it —
|
||||
/// retail "name on the black, bar below". The bar sprite's colored region starts ~y14.</summary>
|
||||
private const float NameBandHeight = 15f;
|
||||
|
||||
// ── Found elements (any may be null for partial/test layouts) ───────────
|
||||
private readonly UiElement? _name;
|
||||
private readonly UiDatElement? _overlay;
|
||||
private readonly UiMeter? _healthMeter;
|
||||
|
||||
// ── Captured delegates ───────────────────────────────────────────────────
|
||||
private readonly Func<uint, bool> _isHealthTarget;
|
||||
private readonly Func<uint, string?> _name_;
|
||||
private readonly Func<uint, float> _healthPercent;
|
||||
private readonly Func<uint, uint> _stackSize;
|
||||
private readonly Action<uint> _sendQueryHealth;
|
||||
private readonly Func<uint, bool> _isHealthTarget;
|
||||
private readonly Func<uint, string?> _resolveName;
|
||||
private readonly Func<uint, float> _healthPercent;
|
||||
private readonly Func<uint, bool> _hasHealth;
|
||||
private readonly Func<uint, uint> _stackSize;
|
||||
private readonly Action<uint> _sendQueryHealth;
|
||||
|
||||
// ── Live state (read by closures on the per-frame draw path) ────────────
|
||||
private uint? _current;
|
||||
private string? _currentName;
|
||||
private double _flashRemaining; // > 0 while the selection overlay is flashing
|
||||
|
||||
/// <summary>White label color for the name line.</summary>
|
||||
private static readonly Vector4 NameColor = new(1f, 1f, 1f, 1f);
|
||||
|
||||
private SelectedObjectController(
|
||||
ImportedLayout layout,
|
||||
Action<Action<uint?>> subscribeSelectionChanged,
|
||||
Action<Action<uint?>> subscribeSelectionChanged,
|
||||
Action<Action<uint, float>> subscribeHealthChanged,
|
||||
Func<uint, bool> isHealthTarget,
|
||||
Func<uint, string?> name,
|
||||
Func<uint, float> healthPercent,
|
||||
Func<uint, bool> hasHealth,
|
||||
Func<uint, uint> stackSize,
|
||||
Action<uint> sendQueryHealth,
|
||||
UiDatFont? datFont)
|
||||
{
|
||||
_isHealthTarget = isHealthTarget;
|
||||
_name_ = name;
|
||||
_resolveName = name;
|
||||
_healthPercent = healthPercent;
|
||||
_hasHealth = hasHealth;
|
||||
_stackSize = stackSize;
|
||||
_sendQueryHealth = sendQueryHealth;
|
||||
|
||||
|
|
@ -81,26 +115,36 @@ public sealed class SelectedObjectController
|
|||
_overlay = layout.FindElement(OverlayId) as UiDatElement;
|
||||
_healthMeter = layout.FindElement(HealthMeterId) as UiMeter;
|
||||
|
||||
// The selection-flash overlay must draw OVER the health meter (which spans the whole
|
||||
// strip) — otherwise the meter hides the green flash whenever a bar is visible (i.e.
|
||||
// for players/monsters). Float it just below the name so the name stays readable.
|
||||
if (_overlay is not null) _overlay.ZOrder = OverlayZOrder;
|
||||
|
||||
// This controller owns the health meter's initial-hidden state.
|
||||
if (_healthMeter is not null)
|
||||
{
|
||||
_healthMeter.Visible = false;
|
||||
// Fill polls live: _current holds the currently-selected guid (or null).
|
||||
// Returns 0f when nothing is selected (empty bar), healthPercent(g) otherwise.
|
||||
_healthMeter.Fill = () => _current is uint g ? _healthPercent(g) : (float?)0f;
|
||||
}
|
||||
|
||||
// Attach a centered UiText child to the name element for the object name display.
|
||||
// Mirrors VitalsController.BindMeter's number attach (same decoration style).
|
||||
// Mirrors VitalsController.BindMeter's number attach. The name is floated to the
|
||||
// top of the strip's z-order so it draws OVER the overlay frame and the health bar
|
||||
// (retail renders the object name over the bar).
|
||||
//
|
||||
// The bar sprite (0x0600193E/F, 146x31) carries a ~14px BLACK name band across its
|
||||
// TOP with the colored bar in the lower portion (confirmed from the dat). Retail
|
||||
// draws the object name in that black band with the health bar BELOW it — so the
|
||||
// label is TOP-aligned by constraining its height to the band, not centered over the
|
||||
// whole 31px strip (which overlapped the bar's middle).
|
||||
if (_name is not null)
|
||||
{
|
||||
_name.ZOrder = NameZOrderOnTop;
|
||||
var label = new UiText
|
||||
{
|
||||
Left = 0f,
|
||||
Top = 0f,
|
||||
Width = _name.Width,
|
||||
Height = _name.Height,
|
||||
Anchors = AnchorEdges.Left | AnchorEdges.Top | AnchorEdges.Right | AnchorEdges.Bottom,
|
||||
Left = 0f, Top = 0f, Width = _name.Width, Height = NameBandHeight,
|
||||
Anchors = AnchorEdges.Left | AnchorEdges.Top | AnchorEdges.Right,
|
||||
Centered = true,
|
||||
DatFont = datFont,
|
||||
ClickThrough = true,
|
||||
|
|
@ -109,7 +153,6 @@ public sealed class SelectedObjectController
|
|||
CapturesPointerDrag = false,
|
||||
LinesProvider = () =>
|
||||
{
|
||||
// Returns a single white line when a name is available; empty otherwise.
|
||||
var n = _currentName;
|
||||
return string.IsNullOrEmpty(n)
|
||||
? Array.Empty<UiText.Line>()
|
||||
|
|
@ -119,90 +162,107 @@ public sealed class SelectedObjectController
|
|||
_name.AddChild(label);
|
||||
}
|
||||
|
||||
// Register the handler LAST so the initial state is fully set up first.
|
||||
// Register the handlers LAST so the initial state is fully set up first.
|
||||
subscribeSelectionChanged(OnSelectionChanged);
|
||||
subscribeHealthChanged(OnHealthChanged);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create and bind a <see cref="SelectedObjectController"/> to <paramref name="layout"/>.
|
||||
/// Port of retail <c>gmToolbarUI::HandleSelectionChanged</c>
|
||||
/// (<c>acclient_2013_pseudo_c.txt:198635</c>).
|
||||
/// Port of retail <c>gmToolbarUI::HandleSelectionChanged</c> + <c>RecvNotice_UpdateObjectHealth</c>.
|
||||
/// </summary>
|
||||
/// <param name="layout">Imported toolbar layout (LayoutDesc 0x21000016).</param>
|
||||
/// <param name="subscribeSelectionChanged">
|
||||
/// Called once with the controller's <see cref="OnSelectionChanged"/> handler.
|
||||
/// Typical host: <c>h => SelectionChanged += h</c> — keeps the controller
|
||||
/// decoupled from <c>GameWindow</c>.
|
||||
/// </param>
|
||||
/// <param name="isHealthTarget">
|
||||
/// Returns true for guids that should show a health meter (proxy for retail's
|
||||
/// <c>IsPlayer() || pet_owner || ObjectIsAttackable()</c>).
|
||||
/// </param>
|
||||
/// <param name="subscribeSelectionChanged">Called once with <see cref="OnSelectionChanged"/>
|
||||
/// (typical host: <c>h => SelectionChanged += h</c>).</param>
|
||||
/// <param name="subscribeHealthChanged">Called once with <see cref="OnHealthChanged"/>
|
||||
/// (typical host: <c>h => Combat.HealthChanged += h</c>) — drives meter visibility.</param>
|
||||
/// <param name="isHealthTarget">Returns true for guids that may show a health meter
|
||||
/// (proxy for retail's <c>IsPlayer() || pet_owner || ObjectIsAttackable()</c>).</param>
|
||||
/// <param name="name">Returns the display name for a given guid (or null if unknown).</param>
|
||||
/// <param name="healthPercent">Returns the health fill fraction [0..1] for a given guid.</param>
|
||||
/// <param name="stackSize">Returns the stack size for a given guid (0 or 1 = non-stacked).</param>
|
||||
/// <param name="sendQueryHealth">
|
||||
/// Sends retail <c>QueryHealth (0x01BF)</c>; server replies with <c>UpdateHealth (0x01C0)</c>.
|
||||
/// May be a no-op when offline.
|
||||
/// </param>
|
||||
/// <param name="hasHealth">Returns true if real health has been received for a guid
|
||||
/// (so a re-selected, already-known target shows its bar immediately).</param>
|
||||
/// <param name="stackSize">Returns the stack size for a guid (0 or 1 = non-stacked).</param>
|
||||
/// <param name="sendQueryHealth">Sends retail <c>QueryHealth (0x01BF)</c>; may be a no-op offline.</param>
|
||||
/// <param name="datFont">Dat font for the name label; null = debug bitmap font fallback.</param>
|
||||
public static SelectedObjectController Bind(
|
||||
ImportedLayout layout,
|
||||
Action<Action<uint?>> subscribeSelectionChanged,
|
||||
Action<Action<uint?>> subscribeSelectionChanged,
|
||||
Action<Action<uint, float>> subscribeHealthChanged,
|
||||
Func<uint, bool> isHealthTarget,
|
||||
Func<uint, string?> name,
|
||||
Func<uint, float> healthPercent,
|
||||
Func<uint, bool> hasHealth,
|
||||
Func<uint, uint> stackSize,
|
||||
Action<uint> sendQueryHealth,
|
||||
UiDatFont? datFont)
|
||||
{
|
||||
return new SelectedObjectController(
|
||||
layout, subscribeSelectionChanged,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont);
|
||||
}
|
||||
=> new SelectedObjectController(
|
||||
layout, subscribeSelectionChanged, subscribeHealthChanged,
|
||||
isHealthTarget, name, healthPercent, hasHealth, stackSize, sendQueryHealth, datFont);
|
||||
|
||||
/// <summary>
|
||||
/// Port of <c>gmToolbarUI::HandleSelectionChanged</c>
|
||||
/// (<c>acclient_2013_pseudo_c.txt:198635</c>):
|
||||
/// Port of <c>gmToolbarUI::HandleSelectionChanged</c> (<c>:198635</c>):
|
||||
/// clear-then-populate the selected-object strip on any selection change.
|
||||
/// Registered via <c>subscribeSelectionChanged</c> at bind time; called by
|
||||
/// <c>GameWindow.SelectionChanged</c> and by the despawn-clear path.
|
||||
/// </summary>
|
||||
public void OnSelectionChanged(uint? guid)
|
||||
{
|
||||
// ── 1. Clear first (retail: UIElement_Text::SetText + m_pSelObjectField->SetState(0)
|
||||
// + SetVisible(0) on the health meter). ──────────────────────────────────────
|
||||
// ── 1. Clear first (retail: SetText("") + m_pSelObjectField->SetState(0)
|
||||
// + SetVisible(0) on the meters). ──────────────────────────────────────
|
||||
if (_healthMeter is not null) _healthMeter.Visible = false;
|
||||
if (_overlay is not null) _overlay.ActiveState = "";
|
||||
_currentName = null;
|
||||
_currentName = null;
|
||||
_current = guid;
|
||||
|
||||
// Update the backing current guid so the Fill closure reflects the new state.
|
||||
_current = guid;
|
||||
|
||||
// ── 2. Selection == null → strip stays cleared, done. ───────────────────────────
|
||||
if (guid is null) return;
|
||||
if (guid is null)
|
||||
{
|
||||
// Deselect: clear the overlay flash immediately too.
|
||||
SetOverlayState("");
|
||||
_flashRemaining = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
uint g = guid.Value;
|
||||
|
||||
// ── 3. Selection != null — populate the strip. ──────────────────────────────────
|
||||
// ── 2. Name (displayed via the UiText child's LinesProvider reading _currentName). ──
|
||||
_currentName = _resolveName(g);
|
||||
|
||||
// Name (displayed via the UiText child's LinesProvider reading _currentName).
|
||||
_currentName = _name_(g);
|
||||
// ── 3. Selection overlay: brief flash (retail container ObjectSelected
|
||||
// = Pause(0.25s)→Normal). "StackedItemSelected" for stacks. ──────────────
|
||||
SetOverlayState(_stackSize(g) > 1u ? "StackedItemSelected" : "ObjectSelected");
|
||||
_flashRemaining = FlashSeconds;
|
||||
|
||||
// Overlay state: "StackedItemSelected" for stacked items, "ObjectSelected" otherwise.
|
||||
// Retail ref: m_pSelObjectField->SetState(0x1000000b) = "ObjectSelected"
|
||||
// (acclient_2013_pseudo_c.txt:198754). Stack sprite id 0x06004CF4 confirmed in toolbar dump.
|
||||
if (_overlay is not null)
|
||||
_overlay.ActiveState = _stackSize(g) > 1u ? "StackedItemSelected" : "ObjectSelected";
|
||||
|
||||
// Health meter: visible + QueryHealth for health-bearing targets.
|
||||
// Divergence: retail shows the meter only when RecvNotice_UpdateObjectHealth arrives;
|
||||
// acdream shows it immediately (fill reads GetHealthPercent = 1.0 until the reply).
|
||||
// Retail ref: CM_Combat::Event_QueryHealth (acclient_2013_pseudo_c.txt:198757).
|
||||
// ── 4. Health: query, and show the meter only if real health is already known.
|
||||
// Otherwise the meter appears when OnHealthChanged fires for this guid
|
||||
// (retail RecvNotice_UpdateObjectHealth :196213). ──────────────────────────
|
||||
if (_isHealthTarget(g))
|
||||
{
|
||||
if (_healthMeter is not null) _healthMeter.Visible = true;
|
||||
_sendQueryHealth(g);
|
||||
if (_hasHealth(g) && _healthMeter is not null)
|
||||
_healthMeter.Visible = true;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Port of <c>gmToolbarUI::RecvNotice_UpdateObjectHealth</c> (<c>:196213</c>): when the
|
||||
/// server reports health for the currently-selected guid, make the Health meter visible.
|
||||
/// The fill value is read live by the meter's <see cref="UiMeter.Fill"/> provider.
|
||||
/// </summary>
|
||||
public void OnHealthChanged(uint guid, float percent)
|
||||
{
|
||||
if (_current is uint c && c == guid && _isHealthTarget(guid) && _healthMeter is not null)
|
||||
_healthMeter.Visible = true;
|
||||
}
|
||||
|
||||
/// <summary>Per-frame tick: reverts the selection overlay after the brief flash window.</summary>
|
||||
public void Tick(double deltaSeconds)
|
||||
{
|
||||
if (_flashRemaining <= 0) return;
|
||||
_flashRemaining -= deltaSeconds;
|
||||
if (_flashRemaining <= 0)
|
||||
SetOverlayState(""); // flash done → overlay back to blank
|
||||
}
|
||||
|
||||
private void SetOverlayState(string state)
|
||||
{
|
||||
if (_overlay is not null) _overlay.ActiveState = state;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,11 +39,13 @@ public sealed class ToolbarController
|
|||
// Ids confirmed from the toolbar LayoutDesc dump.
|
||||
// 0x100001A1 (health meter) is now OWNED by SelectedObjectController (D.5.3a) —
|
||||
// it hides A1 at bind and shows it on a health-target selection, so A1 is removed
|
||||
// from here to avoid double-ownership. 0x100001A2 (mana meter) and 0x100001A4
|
||||
// (stack slider) are DEFERRED features (mana #140, stack-split UI) with no controller
|
||||
// yet, so they stay hidden here — otherwise their dat back-track sprites render as
|
||||
// stray empty bars on the toolbar.
|
||||
private static readonly uint[] HiddenIds = { 0x100001A2, 0x100001A4 };
|
||||
// from here to avoid double-ownership. 0x100001A2 (mana meter), 0x100001A3 (stack-size
|
||||
// entry box) and 0x100001A4 (stack slider) are DEFERRED features (mana #140, stack-split
|
||||
// UI) with no controller yet, so they stay hidden here — otherwise their dat sprites
|
||||
// render as stray bars / a black box on the toolbar. Retail hides A3/A4 in
|
||||
// gmToolbarUI::HandleSelectionChanged (acclient_2013_pseudo_c.txt:198660/198742),
|
||||
// showing them only for a stacked-item selection.
|
||||
private static readonly uint[] HiddenIds = { 0x100001A2, 0x100001A3, 0x100001A4 };
|
||||
|
||||
// Four mutually-exclusive combat-mode indicator elements — exactly one visible at a time.
|
||||
// Index 0 = NonCombat (peace), 1 = Melee, 2 = Missile, 3 = Magic.
|
||||
|
|
|
|||
|
|
@ -135,9 +135,14 @@ public sealed class UiMeter : UiElement
|
|||
{
|
||||
if (clipW <= 0f) return;
|
||||
float w = Width, h = Height;
|
||||
var (lt, lw, _) = resolve(leftId);
|
||||
var (mt, mw, _) = resolve(midId);
|
||||
var (rt, rw, _) = resolve(rightId);
|
||||
// Only resolve a slice when its id is non-zero. resolve(0) returns the 1x1 MAGENTA
|
||||
// placeholder with a NON-ZERO GL handle, so resolving a zero (absent) cap id and then
|
||||
// testing `tex != 0` would draw a 1px magenta cap. The single-image meter (toolbar
|
||||
// selected-object bar) has no left/right caps (ids 0); the 3-slice vitals meter sets
|
||||
// all six ids. Guard on the id, not the resolved handle.
|
||||
var (lt, lw, _) = leftId != 0 ? resolve(leftId) : (0u, 0, 0);
|
||||
var (mt, mw, _) = midId != 0 ? resolve(midId) : (0u, 0, 0);
|
||||
var (rt, rw, _) = rightId != 0 ? resolve(rightId) : (0u, 0, 0);
|
||||
|
||||
float capL = lt != 0 ? MathF.Min(lw, w) : 0f;
|
||||
float capR = rt != 0 ? MathF.Min(rw, w - capL) : 0f;
|
||||
|
|
|
|||
|
|
@ -92,6 +92,16 @@ public sealed class CombatState
|
|||
public float GetHealthPercent(uint guid) =>
|
||||
_healthByGuid.TryGetValue(guid, out var pct) ? pct : 1f;
|
||||
|
||||
/// <summary>
|
||||
/// True if an UpdateHealth (0x01C0) has ever been received for this guid — i.e. the
|
||||
/// server has reported real health for it (via damage broadcast or a successful
|
||||
/// assess/QueryHealth reply). Distinguishes a known value from the 1.0 default that
|
||||
/// <see cref="GetHealthPercent"/> returns for unseen guids. Used by the selected-object
|
||||
/// meter to gate visibility (retail shows the bar only once health is known —
|
||||
/// gmToolbarUI::RecvNotice_UpdateObjectHealth, acclient_2013_pseudo_c.txt:196213).
|
||||
/// </summary>
|
||||
public bool HasHealth(uint guid) => _healthByGuid.ContainsKey(guid);
|
||||
|
||||
public int TrackedTargetCount => _healthByGuid.Count;
|
||||
|
||||
// ── Inbound handlers (wired from WorldSession.GameEvents) ────────────────
|
||||
|
|
|
|||
|
|
@ -10,30 +10,21 @@ namespace AcDream.App.Tests.UI.Layout;
|
|||
|
||||
/// <summary>
|
||||
/// Unit tests for <see cref="SelectedObjectController"/> — the
|
||||
/// <c>gmToolbarUI::HandleSelectionChanged</c> analogue
|
||||
/// (<c>acclient_2013_pseudo_c.txt:198635</c>).
|
||||
/// <c>gmToolbarUI::HandleSelectionChanged</c> + <c>RecvNotice_UpdateObjectHealth</c>
|
||||
/// analogue (<c>acclient_2013_pseudo_c.txt:198635</c> / <c>:196213</c>).
|
||||
///
|
||||
/// <para>
|
||||
/// Layout construction mirrors <see cref="ToolbarControllerTests"/>: build a minimal
|
||||
/// <see cref="ImportedLayout"/> from a root <see cref="UiPanel"/> + a
|
||||
/// <see cref="Dictionary{TKey,TValue}"/> keyed by element id. Elements are constructed
|
||||
/// directly (no importer / no dat / no GL) so tests are pure in-process.
|
||||
/// Key behavior under test: the Health meter is <b>UpdateHealth-driven</b> — it becomes
|
||||
/// visible only when real health is known for the selected guid (a <c>HealthChanged</c>
|
||||
/// fires for it, or it is already cached at select time via <c>hasHealth</c>). Selecting a
|
||||
/// target does NOT show the meter on its own. This matches retail: a friendly NPC you have
|
||||
/// not assessed shows name-only; a monster's bar appears after damage / assess.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public class SelectedObjectControllerTests
|
||||
{
|
||||
// ── Shared layout ────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Build a minimal toolbar layout containing the three selected-object elements:
|
||||
/// <list type="bullet">
|
||||
/// <item>0x1000019F → a <see cref="UiPanel"/> name container (100×20).</item>
|
||||
/// <item>0x100001A0 → a <see cref="UiDatElement"/> overlay with "ObjectSelected"
|
||||
/// and "StackedItemSelected" states wired to distinct file ids.</item>
|
||||
/// <item>0x100001A1 → a <see cref="UiMeter"/> health meter.</item>
|
||||
/// </list>
|
||||
/// Additional element ids can be added by the caller for edge-case tests.
|
||||
/// </summary>
|
||||
private static (
|
||||
ImportedLayout layout,
|
||||
UiPanel nameEl,
|
||||
|
|
@ -44,28 +35,25 @@ public class SelectedObjectControllerTests
|
|||
var dict = new Dictionary<uint, UiElement>();
|
||||
var root = new UiPanel();
|
||||
|
||||
// Name element: a plain panel that will have a UiText child attached by the controller.
|
||||
var nameEl = new UiPanel { Width = 100, Height = 20 };
|
||||
dict[SelectedObjectController.NameId] = nameEl;
|
||||
root.AddChild(nameEl);
|
||||
|
||||
// Overlay element: a UiDatElement with the two named states the controller switches between.
|
||||
var overlayInfo = new ElementInfo
|
||||
{
|
||||
Id = SelectedObjectController.OverlayId,
|
||||
Type = 3, // Type 3 = container/chrome — the overlay field's dat type
|
||||
Type = 3,
|
||||
StateMedia =
|
||||
{
|
||||
[""] = (0x06000001u, 3), // DirectState (blank)
|
||||
["ObjectSelected"] = (0x06001937u, 3), // ObjectSelected sprite id from toolbar dump
|
||||
["StackedItemSelected"] = (0x06004CF4u, 3), // StackedItemSelected sprite id
|
||||
[""] = (0x06000001u, 3),
|
||||
["ObjectSelected"] = (0x06001937u, 3),
|
||||
["StackedItemSelected"] = (0x06004CF4u, 3),
|
||||
},
|
||||
};
|
||||
var overlayEl = new UiDatElement(overlayInfo, _ => (0u, 0, 0));
|
||||
dict[SelectedObjectController.OverlayId] = overlayEl;
|
||||
root.AddChild(overlayEl);
|
||||
|
||||
// Health meter element.
|
||||
var healthMeterEl = new UiMeter { Width = 100, Height = 10, Visible = true };
|
||||
dict[SelectedObjectController.HealthMeterId] = healthMeterEl;
|
||||
root.AddChild(healthMeterEl);
|
||||
|
|
@ -75,387 +63,344 @@ public class SelectedObjectControllerTests
|
|||
|
||||
// ── Recording delegates ──────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Build a recording set of delegates. Name, health, stack are keyed by guid;
|
||||
/// <paramref name="queryHealthCalls"/> accumulates every guid passed to sendQueryHealth.
|
||||
/// </summary>
|
||||
private static (
|
||||
Action<Action<uint?>> subscribe,
|
||||
Action<uint?> fireSelection,
|
||||
Func<uint, bool> isHealthTarget,
|
||||
Func<uint, string?> name,
|
||||
Func<uint, float> healthPercent,
|
||||
Func<uint, uint> stackSize,
|
||||
Action<uint> sendQueryHealth,
|
||||
List<uint> queryHealthCalls)
|
||||
MakeDelegates(
|
||||
Dictionary<uint, bool> healthTargetMap,
|
||||
Dictionary<uint, string> nameMap,
|
||||
Dictionary<uint, float> healthMap,
|
||||
Dictionary<uint, uint> stackMap)
|
||||
private sealed class Harness
|
||||
{
|
||||
Action<uint?>? registeredHandler = null;
|
||||
var queryHealthCalls = new List<uint>();
|
||||
public Action<uint?>? SelectionHandler;
|
||||
public Action<uint, float>? HealthHandler;
|
||||
public readonly List<uint> QueryHealthCalls = new();
|
||||
|
||||
Action<Action<uint?>> subscribe = h => registeredHandler = h;
|
||||
Action<uint?> fireSelection = guid => registeredHandler?.Invoke(guid);
|
||||
public readonly Dictionary<uint, bool> HealthTargetMap = new();
|
||||
public readonly Dictionary<uint, string> NameMap = new();
|
||||
public readonly Dictionary<uint, float> HealthMap = new();
|
||||
public readonly Dictionary<uint, bool> HasHealthMap = new();
|
||||
public readonly Dictionary<uint, uint> StackMap = new();
|
||||
|
||||
Func<uint, bool> isHealthTarget = g => healthTargetMap.TryGetValue(g, out var v) && v;
|
||||
Func<uint, string?> name = g => nameMap.TryGetValue(g, out var v) ? v : null;
|
||||
Func<uint, float> healthPercent = g => healthMap.TryGetValue(g, out var v) ? v : 1f;
|
||||
Func<uint, uint> stackSize = g => stackMap.TryGetValue(g, out var v) ? v : 0u;
|
||||
Action<uint> sendQueryHealth = g => queryHealthCalls.Add(g);
|
||||
public void FireSelection(uint? g) => SelectionHandler?.Invoke(g);
|
||||
public void FireHealth(uint g, float pct) => HealthHandler?.Invoke(g, pct);
|
||||
|
||||
return (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, queryHealthCalls);
|
||||
public SelectedObjectController Bind(ImportedLayout layout, UiDatFont? datFont = null)
|
||||
=> SelectedObjectController.Bind(
|
||||
layout,
|
||||
subscribeSelectionChanged: h => SelectionHandler = h,
|
||||
subscribeHealthChanged: h => HealthHandler = h,
|
||||
isHealthTarget: g => HealthTargetMap.TryGetValue(g, out var v) && v,
|
||||
name: g => NameMap.TryGetValue(g, out var v) ? v : null,
|
||||
healthPercent: g => HealthMap.TryGetValue(g, out var v) ? v : 1f,
|
||||
hasHealth: g => HasHealthMap.TryGetValue(g, out var v) && v,
|
||||
stackSize: g => StackMap.TryGetValue(g, out var v) ? v : 0u,
|
||||
sendQueryHealth: g => QueryHealthCalls.Add(g),
|
||||
datFont: datFont);
|
||||
}
|
||||
|
||||
// ── B1: Bind initialisation ──────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// After Bind:
|
||||
/// - the health meter is hidden (controller owns initial-hidden state).
|
||||
/// - the name element has exactly one UiText child (the name label).
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Bind_healthMeterHidden_andNameTextChildAttached()
|
||||
public void Bind_healthMeterHidden_nameTextChildAttached_nameFloatedOnTop()
|
||||
{
|
||||
var (layout, nameEl, _, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, _, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new(),
|
||||
nameMap: new(),
|
||||
healthMap: new(),
|
||||
stackMap: new());
|
||||
new Harness().Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
Assert.False(healthMeterEl.Visible, "health meter must be Visible=false immediately after Bind");
|
||||
|
||||
// Health meter must start hidden.
|
||||
Assert.False(healthMeterEl.Visible,
|
||||
"health meter must be Visible=false immediately after Bind");
|
||||
|
||||
// A UiText child should have been attached to the name element.
|
||||
var textChild = nameEl.Children.OfType<UiText>().SingleOrDefault();
|
||||
Assert.NotNull(textChild);
|
||||
Assert.True(textChild!.Centered, "name UiText must be Centered");
|
||||
Assert.True(textChild.ClickThrough, "name UiText must be ClickThrough (non-interactive decoration)");
|
||||
Assert.True(textChild!.Centered, "name UiText must be Centered");
|
||||
Assert.True(textChild.ClickThrough, "name UiText must be ClickThrough");
|
||||
Assert.False(textChild.AcceptsFocus, "AcceptsFocus must be false on name label");
|
||||
Assert.False(textChild.IsEditControl, "IsEditControl must be false on name label");
|
||||
Assert.False(textChild.CapturesPointerDrag, "CapturesPointerDrag must be false on name label");
|
||||
|
||||
// The name element must be floated to the top of the strip's z-order so it draws
|
||||
// OVER the overlay frame and the health bar (retail draws the name over the bar).
|
||||
Assert.True(nameEl.ZOrder > 1000, "name element must be floated above the overlay/meter z-order");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// After Bind, the attached UiText's LinesProvider yields no lines (nothing selected yet).
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void Bind_nameLinesProvider_yieldsEmpty_whenNothingSelected()
|
||||
{
|
||||
var (layout, nameEl, _, _) = FakeLayout();
|
||||
var (subscribe, _, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(new(), new(), new(), new());
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
new Harness().Bind(layout);
|
||||
|
||||
var textChild = nameEl.Children.OfType<UiText>().Single();
|
||||
var lines = textChild.LinesProvider();
|
||||
Assert.Empty(lines);
|
||||
Assert.Empty(textChild.LinesProvider());
|
||||
}
|
||||
|
||||
// ── H1: Select a health target (creature) ───────────────────────────────
|
||||
// ── H1: Select a health target — meter does NOT show on select alone ─────
|
||||
|
||||
/// <summary>
|
||||
/// Selecting a health target (stackSize=1, isHealthTarget=true):
|
||||
/// - overlay ActiveState == "ObjectSelected"
|
||||
/// - meter Visible == true
|
||||
/// - sendQueryHealth invoked exactly once with the guid
|
||||
/// - name LinesProvider yields a single white line with the expected name
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SelectHealthTarget_meterVisible_overlayObjectSelected_queryHealthFired()
|
||||
public void SelectHealthTarget_unknownHealth_meterStaysHidden_queryFired_nameAndOverlaySet()
|
||||
{
|
||||
const uint Guid = 0xAA01u;
|
||||
const string ExpectedName = "Drudge Prowler";
|
||||
|
||||
var (layout, nameEl, overlayEl, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, queryHealthCalls) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = true },
|
||||
nameMap: new() { [Guid] = ExpectedName },
|
||||
healthMap: new() { [Guid] = 0.75f },
|
||||
stackMap: new() { [Guid] = 1u }); // stackSize=1 → ObjectSelected
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.NameMap[Guid] = ExpectedName;
|
||||
h.StackMap[Guid] = 1u; // ObjectSelected
|
||||
// HasHealthMap[Guid] not set → false (no health known yet)
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
h.FireSelection(Guid);
|
||||
|
||||
// Fire the selection.
|
||||
fireSelection(Guid);
|
||||
|
||||
Assert.True(healthMeterEl.Visible,
|
||||
"health meter must become Visible after selecting a health target");
|
||||
// Health not yet known → meter must stay hidden (retail: shows on UpdateHealth).
|
||||
Assert.False(healthMeterEl.Visible,
|
||||
"meter must stay hidden on select when no health is known yet");
|
||||
// But QueryHealth is sent (retail Event_QueryHealth on select for a health target).
|
||||
Assert.Single(h.QueryHealthCalls);
|
||||
Assert.Equal(Guid, h.QueryHealthCalls[0]);
|
||||
Assert.Equal("ObjectSelected", overlayEl.ActiveState);
|
||||
Assert.Single(queryHealthCalls);
|
||||
Assert.Equal(Guid, queryHealthCalls[0]);
|
||||
|
||||
// Name label: the LinesProvider should yield the creature's name as a white line.
|
||||
var textChild = nameEl.Children.OfType<UiText>().Single();
|
||||
var lines = textChild.LinesProvider();
|
||||
var lines = nameEl.Children.OfType<UiText>().Single().LinesProvider();
|
||||
Assert.Single(lines);
|
||||
Assert.Equal(ExpectedName, lines[0].Text);
|
||||
Assert.Equal(new Vector4(1f, 1f, 1f, 1f), lines[0].Color);
|
||||
}
|
||||
|
||||
// ── H2: Select a stacked item ────────────────────────────────────────────
|
||||
// ── H1b: Health arrives for the selected guid → meter appears ───────────
|
||||
|
||||
/// <summary>
|
||||
/// Selecting a stacked item (stackSize > 1): overlay ActiveState == "StackedItemSelected".
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SelectStackedItem_overlayStackedItemSelected()
|
||||
public void HealthChanged_forSelectedGuid_showsMeter()
|
||||
{
|
||||
const uint Guid = 0xAA02u;
|
||||
|
||||
var (layout, _, _, healthMeterEl) = FakeLayout();
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.NameMap[Guid] = "Drudge Slinker";
|
||||
h.Bind(layout);
|
||||
|
||||
h.FireSelection(Guid);
|
||||
Assert.False(healthMeterEl.Visible, "hidden until health arrives");
|
||||
|
||||
// Simulate UpdateHealth (0x01C0) for the selected guid.
|
||||
h.FireHealth(Guid, 0.6f);
|
||||
Assert.True(healthMeterEl.Visible, "meter must appear when health arrives for the selected guid");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void HealthChanged_forOtherGuid_doesNotShowMeter()
|
||||
{
|
||||
const uint Sel = 0xAA03u, Other = 0xBB03u;
|
||||
|
||||
var (layout, _, _, healthMeterEl) = FakeLayout();
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Sel] = true;
|
||||
h.HealthTargetMap[Other] = true;
|
||||
h.NameMap[Sel] = "Selected";
|
||||
h.Bind(layout);
|
||||
|
||||
h.FireSelection(Sel);
|
||||
h.FireHealth(Other, 0.5f); // health for a DIFFERENT entity
|
||||
|
||||
Assert.False(healthMeterEl.Visible, "health for a non-selected guid must not show the meter");
|
||||
}
|
||||
|
||||
// ── H1c: Already-known health → meter shows immediately on select ───────
|
||||
|
||||
[Fact]
|
||||
public void SelectHealthTarget_alreadyKnownHealth_meterVisibleImmediately()
|
||||
{
|
||||
const uint Guid = 0xAA04u;
|
||||
|
||||
var (layout, _, _, healthMeterEl) = FakeLayout();
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.HasHealthMap[Guid] = true; // health already cached (e.g. previously assessed)
|
||||
h.HealthMap[Guid] = 0.9f;
|
||||
h.NameMap[Guid] = "Olthoi";
|
||||
h.Bind(layout);
|
||||
|
||||
h.FireSelection(Guid);
|
||||
Assert.True(healthMeterEl.Visible,
|
||||
"meter must show immediately when health is already known for the target");
|
||||
}
|
||||
|
||||
// ── H2: Stacked item ─────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void SelectStackedItem_overlayStackedItemSelected_meterHidden()
|
||||
{
|
||||
const uint Guid = 0xBB02u;
|
||||
|
||||
var (layout, _, overlayEl, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = false },
|
||||
nameMap: new() { [Guid] = "Heal Kits" },
|
||||
healthMap: new(),
|
||||
stackMap: new() { [Guid] = 5u }); // stackSize > 1
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = false;
|
||||
h.NameMap[Guid] = "Heal Kits";
|
||||
h.StackMap[Guid] = 5u; // stackSize > 1
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
|
||||
fireSelection(Guid);
|
||||
h.FireSelection(Guid);
|
||||
|
||||
Assert.Equal("StackedItemSelected", overlayEl.ActiveState);
|
||||
// Not a health target → meter stays hidden.
|
||||
Assert.False(healthMeterEl.Visible);
|
||||
}
|
||||
|
||||
// ── H3: Select a non-health target (friendly NPC / scenery) ─────────────
|
||||
// ── H3: Non-health target (friendly NPC / scenery / Door) ───────────────
|
||||
|
||||
/// <summary>
|
||||
/// Selecting a non-health target (isHealthTarget=false):
|
||||
/// - meter stays hidden
|
||||
/// - sendQueryHealth NOT invoked
|
||||
/// - name and overlay are still set
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SelectNonHealthTarget_meterHidden_noQueryHealth_nameSet()
|
||||
public void SelectNonHealthTarget_meterHidden_noQuery_nameSet()
|
||||
{
|
||||
const uint Guid = 0xCC03u;
|
||||
const string ExpectedName = "Town Crier";
|
||||
|
||||
var (layout, nameEl, overlayEl, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, queryHealthCalls) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = false },
|
||||
nameMap: new() { [Guid] = ExpectedName },
|
||||
healthMap: new(),
|
||||
stackMap: new() { [Guid] = 0u }); // non-stack → ObjectSelected
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = false;
|
||||
h.NameMap[Guid] = ExpectedName;
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
|
||||
fireSelection(Guid);
|
||||
h.FireSelection(Guid);
|
||||
|
||||
Assert.False(healthMeterEl.Visible, "meter must stay hidden for a non-health target");
|
||||
Assert.Empty(queryHealthCalls); // sendQueryHealth must NOT be invoked for a non-health target
|
||||
|
||||
// Overlay and name are still populated.
|
||||
Assert.Empty(h.QueryHealthCalls);
|
||||
Assert.Equal("ObjectSelected", overlayEl.ActiveState);
|
||||
var textChild = nameEl.Children.OfType<UiText>().Single();
|
||||
var lines = textChild.LinesProvider();
|
||||
|
||||
var lines = nameEl.Children.OfType<UiText>().Single().LinesProvider();
|
||||
Assert.Single(lines);
|
||||
Assert.Equal(ExpectedName, lines[0].Text);
|
||||
}
|
||||
|
||||
// ── H4: Deselect (null) ──────────────────────────────────────────────────
|
||||
// ── H4: Deselect clears the strip ────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Selecting null clears the strip:
|
||||
/// - meter Visible == false
|
||||
/// - overlay ActiveState == ""
|
||||
/// - name LinesProvider yields empty
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void SelectNull_clearsStrip()
|
||||
{
|
||||
const uint Guid = 0xDD04u;
|
||||
|
||||
var (layout, nameEl, overlayEl, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = true },
|
||||
nameMap: new() { [Guid] = "Wolf" },
|
||||
healthMap: new() { [Guid] = 0.5f },
|
||||
stackMap: new() { [Guid] = 0u });
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.HasHealthMap[Guid] = true; // so the meter is shown on select
|
||||
h.HealthMap[Guid] = 0.5f;
|
||||
h.NameMap[Guid] = "Wolf";
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
|
||||
// First select something...
|
||||
fireSelection(Guid);
|
||||
h.FireSelection(Guid);
|
||||
Assert.True(healthMeterEl.Visible);
|
||||
|
||||
// ...then deselect.
|
||||
fireSelection(null);
|
||||
h.FireSelection(null);
|
||||
|
||||
Assert.False(healthMeterEl.Visible, "meter must be hidden after deselect");
|
||||
Assert.Equal("", overlayEl.ActiveState);
|
||||
|
||||
var textChild = nameEl.Children.OfType<UiText>().Single();
|
||||
var lines = textChild.LinesProvider();
|
||||
Assert.Empty(lines);
|
||||
Assert.Empty(nameEl.Children.OfType<UiText>().Single().LinesProvider());
|
||||
}
|
||||
|
||||
// ── H5: Clear → new selection (re-select) ────────────────────────────────
|
||||
// ── H5: Re-select a different guid ───────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Selecting one target then another should clear the first and apply the second.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void ReSelect_differentGuid_clearsFirstThenAppliesSecond()
|
||||
{
|
||||
const uint GuidA = 0xEE05u;
|
||||
const uint GuidB = 0xFF06u;
|
||||
const uint GuidA = 0xEE05u, GuidB = 0xFF06u;
|
||||
|
||||
var (layout, nameEl, overlayEl, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, queryHealthCalls) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [GuidA] = true, [GuidB] = false },
|
||||
nameMap: new() { [GuidA] = "Bandit", [GuidB] = "Chest" },
|
||||
healthMap: new() { [GuidA] = 1.0f },
|
||||
stackMap: new() { [GuidA] = 0u, [GuidB] = 0u });
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[GuidA] = true; h.HealthTargetMap[GuidB] = false;
|
||||
h.HasHealthMap[GuidA] = true; // A shows its bar on select
|
||||
h.NameMap[GuidA] = "Bandit"; h.NameMap[GuidB] = "Chest";
|
||||
h.HealthMap[GuidA] = 1.0f;
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
|
||||
// Select A (health target).
|
||||
fireSelection(GuidA);
|
||||
h.FireSelection(GuidA);
|
||||
Assert.True(healthMeterEl.Visible);
|
||||
Assert.Single(queryHealthCalls);
|
||||
Assert.Single(h.QueryHealthCalls);
|
||||
|
||||
// Select B (non-health target) — must clear A's state and apply B.
|
||||
fireSelection(GuidB);
|
||||
h.FireSelection(GuidB);
|
||||
|
||||
Assert.False(healthMeterEl.Visible, "health meter must be cleared when switching to non-health target");
|
||||
Assert.False(healthMeterEl.Visible, "meter must clear when switching to a non-health target");
|
||||
Assert.Equal("ObjectSelected", overlayEl.ActiveState);
|
||||
// sendQueryHealth must NOT be called again (B is not a health target).
|
||||
Assert.Single(queryHealthCalls);
|
||||
Assert.Single(h.QueryHealthCalls); // B is not a health target → no extra query
|
||||
|
||||
// Name should reflect B.
|
||||
var textChild = nameEl.Children.OfType<UiText>().Single();
|
||||
var lines = textChild.LinesProvider();
|
||||
var lines = nameEl.Children.OfType<UiText>().Single().LinesProvider();
|
||||
Assert.Single(lines);
|
||||
Assert.Equal("Chest", lines[0].Text);
|
||||
}
|
||||
|
||||
// ── H6: Partial layout (missing elements) ────────────────────────────────
|
||||
// ── H6: Overlay flash reverts after the flash window (Tick) ─────────────
|
||||
|
||||
[Fact]
|
||||
public void Tick_revertsOverlayFlash_afterDuration()
|
||||
{
|
||||
const uint Guid = 0xAB06u;
|
||||
|
||||
var (layout, _, overlayEl, _) = FakeLayout();
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = false;
|
||||
h.NameMap[Guid] = "Lever";
|
||||
var c = h.Bind(layout);
|
||||
|
||||
h.FireSelection(Guid);
|
||||
Assert.Equal("ObjectSelected", overlayEl.ActiveState);
|
||||
|
||||
// A small tick before the window elapses → still flashing.
|
||||
c.Tick(0.1);
|
||||
Assert.Equal("ObjectSelected", overlayEl.ActiveState);
|
||||
|
||||
// Tick past the 0.25s window → overlay reverts to blank.
|
||||
c.Tick(0.2);
|
||||
Assert.Equal("", overlayEl.ActiveState);
|
||||
}
|
||||
|
||||
// ── H7: Partial layout (missing elements) ────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// When elements are absent (partial layout), Bind does not throw and
|
||||
/// OnSelectionChanged does not throw for any combination.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void PartialLayout_noElements_doesNotThrow()
|
||||
{
|
||||
// Empty layout — none of the three ids are present.
|
||||
var root = new UiPanel();
|
||||
var layout = new ImportedLayout(root, new Dictionary<uint, UiElement>());
|
||||
|
||||
Action<uint?>? registeredHandler = null;
|
||||
var queryHealthCalls = new List<uint>();
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[0x12345678u] = true;
|
||||
h.NameMap[0x12345678u] = "Something";
|
||||
var c = h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(
|
||||
layout,
|
||||
subscribeSelectionChanged: h => registeredHandler = h,
|
||||
isHealthTarget: _ => true,
|
||||
name: _ => "Something",
|
||||
healthPercent: _ => 1f,
|
||||
stackSize: _ => 0u,
|
||||
sendQueryHealth: g => queryHealthCalls.Add(g),
|
||||
datFont: null);
|
||||
Assert.NotNull(h.SelectionHandler);
|
||||
Assert.Null(Record.Exception(() => h.FireSelection(0x12345678u)));
|
||||
Assert.Null(Record.Exception(() => h.FireHealth(0x12345678u, 0.5f)));
|
||||
Assert.Null(Record.Exception(() => c.Tick(0.5)));
|
||||
Assert.Null(Record.Exception(() => h.FireSelection(null)));
|
||||
|
||||
Assert.NotNull(registeredHandler);
|
||||
|
||||
// Firing selection / deselection on a partial layout must not throw.
|
||||
var ex = Record.Exception(() => registeredHandler!.Invoke(0x12345678u));
|
||||
Assert.Null(ex);
|
||||
|
||||
ex = Record.Exception(() => registeredHandler!.Invoke(null));
|
||||
Assert.Null(ex);
|
||||
|
||||
// QueryHealth must still be called (the delegate doesn't depend on the meter element).
|
||||
Assert.Single(queryHealthCalls);
|
||||
Assert.Equal(0x12345678u, queryHealthCalls[0]);
|
||||
Assert.Single(h.QueryHealthCalls);
|
||||
Assert.Equal(0x12345678u, h.QueryHealthCalls[0]);
|
||||
}
|
||||
|
||||
// ── H7: Fill closure reflects live healthPercent ─────────────────────────
|
||||
// ── H8: Fill reflects live health; returns 0 when nothing selected ──────
|
||||
|
||||
/// <summary>
|
||||
/// The meter's Fill closure reads the current guid's health percent from the
|
||||
/// <c>healthPercent</c> delegate on every poll — so if the server updates the
|
||||
/// health between polls the fill reflects the new value without re-selecting.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void HealthMeterFill_reflectsLiveHealthPercent()
|
||||
{
|
||||
const uint Guid = 0xAA07u;
|
||||
float currentHealth = 0.5f;
|
||||
|
||||
var (layout, _, _, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, _, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = true },
|
||||
nameMap: new() { [Guid] = "Arwic Banderling" },
|
||||
healthMap: new(), // not used here
|
||||
stackMap: new() { [Guid] = 0u });
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.NameMap[Guid] = "Arwic Banderling";
|
||||
h.HealthMap[Guid] = 0.5f;
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name,
|
||||
healthPercent: _ => currentHealth, // reads the captured variable
|
||||
stackSize, sendQueryHealth, datFont: null);
|
||||
|
||||
fireSelection(Guid);
|
||||
|
||||
// Fill should return the current health value.
|
||||
h.FireSelection(Guid);
|
||||
Assert.Equal(0.5f, healthMeterEl.Fill());
|
||||
|
||||
// Simulate server updating health (as if UpdateHealth 0x01C0 arrived).
|
||||
currentHealth = 0.25f;
|
||||
h.HealthMap[Guid] = 0.25f; // server updates health
|
||||
Assert.Equal(0.25f, healthMeterEl.Fill());
|
||||
}
|
||||
|
||||
// ── H8: Fill returns 0 when nothing is selected ──────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// After deselect, the meter Fill returns 0f (empty bar) rather than
|
||||
/// the last selected target's health value.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void HealthMeterFill_returnsZero_whenNothingSelected()
|
||||
{
|
||||
const uint Guid = 0xAA08u;
|
||||
|
||||
var (layout, _, _, healthMeterEl) = FakeLayout();
|
||||
var (subscribe, fireSelection, isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, _) =
|
||||
MakeDelegates(
|
||||
healthTargetMap: new() { [Guid] = true },
|
||||
nameMap: new() { [Guid] = "Spider" },
|
||||
healthMap: new() { [Guid] = 0.8f },
|
||||
stackMap: new() { [Guid] = 0u });
|
||||
var h = new Harness();
|
||||
h.HealthTargetMap[Guid] = true;
|
||||
h.NameMap[Guid] = "Spider";
|
||||
h.HealthMap[Guid] = 0.8f;
|
||||
h.Bind(layout);
|
||||
|
||||
SelectedObjectController.Bind(layout, subscribe,
|
||||
isHealthTarget, name, healthPercent, stackSize, sendQueryHealth, datFont: null);
|
||||
h.FireSelection(Guid);
|
||||
Assert.Equal(0.8f, healthMeterEl.Fill());
|
||||
|
||||
fireSelection(Guid);
|
||||
Assert.Equal(0.8f, healthMeterEl.Fill()); // sanity check
|
||||
|
||||
fireSelection(null);
|
||||
// After deselect, Fill() must return 0f (or null coerced to 0f).
|
||||
var fill = healthMeterEl.Fill();
|
||||
Assert.Equal(0f, fill ?? 0f);
|
||||
h.FireSelection(null);
|
||||
Assert.Equal(0f, healthMeterEl.Fill() ?? 0f);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue