fix(combat): #298 — admit player targets to melee/missile attack and the camera

Selecting a PKLite player and attacking did nothing: with auto-target on it
retargeted to the nearest monster, with auto-target off it logged
"combat: attack ignored; no creature target found". Spells on the same target
worked, which was the clue.

Root cause: CombatTargetPolicy.IsHostileMonster:31-33 rejects any candidate
carrying BfPlayer BEFORE reaching ObjectIsAttackable, so the both-PKLite pool
match at SelectedObjectHealthPolicy.cs:70-71 was unreachable for players. Melee
and missile targeting never supported player targets at all — the gate is named
IsHostileMonster and does exactly what it says. Nobody could hit it until
69ba9486 made PK Lite reachable.

Retail uses ONE predicate for monsters and players, with no player exclusion:
ClientCombatSystem::ExecuteAttack @0x0056BB70 gates unconditionally on
ObjectIsAttackable @0x0056A600 (creature type, Free-PK short-circuit on either
side, then IsPlayer -> bothPK || bothPKLite, else BF_ATTACKABLE with pets
excluded). acdream already ported that predicate verbatim; it was simply
unreachable.

The fix SPLITS the two concerns rather than relaxing the shared predicate:
explicit-target admission routes through ObjectIsAttackable, while auto-target
ACQUISITION keeps the monster-only gate. That is required by register row
IA-19 — explicit product direction that Auto Target must never select NPCs,
players or pets. IA-19 is not overridden here; its own justification promises
"manual player-selection commands remain available", and that promise was never
implemented, so this makes the row true. Review confirmed no path lets
auto-acquisition select a player: every automatic Select is fed by a
FindClosest* filtered through IsHostileMonster.

Review also found a second site with the same bug, which the first pass froze in
place on my instruction: retail gates combat-camera tracking on the SAME
predicate as the attack. ClientCombatSystem::UpdateTargetTracking @0x0056A950
reads GetAttackTarget() then gates CameraSet::TrackTarget on ObjectIsAttackable.
Ours used the monster-only gate, so with ViewCombatTarget on by default the
attack would land while the camera refused to track the opponent — user-visible
in exactly the duel this fix enables. GetCombatCameraTargetPoint now uses the
wide predicate. IA-19 does not reach the camera: it performs no acquisition,
only presentation on an already-chosen target. The first pass had added a
source comment asserting IA-19 covered it; that comment and the matching text in
docs/ISSUES.md are corrected, since a wrong citation is how a real divergence
becomes invisible.

Depends on 9b1e6fc6 (#297): the both-PKLite arm needs the LOCAL player's own bit
to be live. Review confirmed both admission sites read ClientObjectTable on every
call, so this is not inert in production.

Newly reachable and now pinned: ObjectIsAttackable's pet-exclusion arm, which
CombatTargetPolicy rejected before it could ever run.

Follow-ups filed: #304 (SelectionInteractionController.GetSelectedOrClosestCombatTarget
has no production caller — one of the two widened call sites is dead code),
#305 (HeadlessGameplayOperations has the identical pre-existing bug, so the
graphical/headless hosts now diverge).

Gates: complete Release solution 10,904 passed / 4 skipped / 0 failed (baseline
10,900). Adversarial + retail-conformance review PASS after one FAIL round; the
predicate was re-verified branch-for-branch against 0x0056A600 since it goes
live here for the first time. Camera fix discrimination-verified by revert.
Connected acceptance NOT run — needs a live two-client PKLite session.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

docs/ISSUES.md

@@ -500,19 +500,31 @@ it. Do #297 FIRST — #298 depends on it.
   `BF_ATTACKABLE` with pets excluded. We already have that predicate ported
   verbatim and correctly at `SelectedObjectHealthPolicy.cs:41-78` — it is
   simply unreachable.
-  **DO NOT fix by relaxing the shared predicate.** `IsHostileMonster` also
-  backs auto-target ACQUISITION (`CombatAttackTargetSource.cs:80`,
-  `WorldSelectionQuery.cs:255`) and the combat camera
-  (`WorldSelectionQuery.cs:264-269`), and relaxing it would violate register row
-  **IA-19**, explicit product direction that auto-target must never select
-  NPCs, players or pets. Retail's own auto-target DOES admit players
-  (@0x0056C040 pc:377318-377327), so retail and IA-19 genuinely disagree here.
-  Fix shape: SPLIT explicit-target admission (-> `ObjectIsAttackable`,
-  retail-exact) from auto-acquisition (-> keep `IsHostileMonster`, IA-19
-  intact). IA-19's own text already promises "manual player-selection commands
-  remain available"; that promise is currently unimplemented, which is the real
-  gap. Not affected: the health bar (`SelectedObjectHealthPolicy.cs:32` already
-  admits `BfPlayer`) and the vivid target indicator.
+  **DO NOT fix by relaxing `IsHostileMonster`'s automatic-acquisition
+  scope.** `IsHostileMonster` also backs auto-target ACQUISITION
+  (`CombatAttackTargetSource.cs:80`, `WorldSelectionQuery.cs:280`), and
+  relaxing it would violate register row **IA-19**, explicit product
+  direction that auto-target must never select NPCs, players or pets.
+  Retail's own auto-target DOES admit players (@0x0056C040
+  pc:377318-377327), so retail and IA-19 genuinely disagree here — for
+  acquisition only.
+  **The combat camera is NOT an IA-19 concern, despite an earlier draft of
+  this note claiming otherwise.** Retail `ClientCombatSystem::
+  UpdateTargetTracking` @0x0056A950 (pc:375691-375696) gates
+  `CameraSet::TrackTarget` on the SAME `ObjectIsAttackable` predicate as
+  `ExecuteAttack` @0x0056BB98, not the narrow monster-only policy. The
+  camera performs no acquisition of its own — it only tracks whatever the
+  player already selected — so `WorldSelectionQuery.GetCombatCameraTargetPoint`
+  must route through the wide predicate exactly like explicit-target
+  admission. (Landed: `GetCombatCameraTargetPoint` now calls
+  `IsAttackableTarget`.)
+  Fix shape: SPLIT explicit-target admission AND the combat camera
+  (-> `ObjectIsAttackable`/`IsAttackableTarget`, retail-exact) from
+  auto-acquisition (-> keep `IsHostileMonster`, IA-19 intact). IA-19's own
+  text already promises "manual player-selection commands remain
+  available"; that promise was unimplemented before this fix. Not affected:
+  the health bar (`SelectedObjectHealthPolicy.cs:32` already admits
+  `BfPlayer`) and the vivid target indicator.
   Correct model to copy: spells already work on PKLite players because
   `RetailSpellTargetPolicy.cs:40-46` treats `BF_PLAYER` as an ACCEPT and never
   calls `ObjectIsAttackable` — the client checks target-TYPE compatibility and
@@ -580,6 +592,41 @@ it. Do #297 FIRST — #298 depends on it.
   `LiveEntityCollisionBuilder` and therefore no live-entity target shadows), so
   this is shape rather than a defect. Filed from the #297 delta review.
 
+## Follow-ups from the #298 fix and its review — 2026-08-03
+
+- **#304 — OPEN — `SelectionInteractionController.GetSelectedOrClosestCombatTarget`
+  has no production caller. LOW/shape.** Grep confirms only tests reach it
+  (`GetSelectedOrClosestCombatTarget:114-121`); no `GameplayInputActionRouter`
+  or other App wiring calls it. The #298 fix widened it correctly (explicit
+  selection now checks `IWorldSelectionQuery.IsAttackableTarget` instead of
+  `IsHostileMonster`), matching `CombatAttackTargetSource`'s live path
+  defensively, but it currently exists only to keep the (also unused-in-
+  production) `IsAttackableTarget` member exercised by four `IWorldSelectionQuery`
+  fakes. Fix shape: delete the dead method (and, if nothing else calls
+  `IsAttackableTarget` through this interface after that, the interface member
+  and its fake stubs too) — or find the caller that was supposed to exist and
+  wire it. Filed from the #298 review.
+
+- **#305 — OPEN — `HeadlessGameplayOperations.GetSelectedOrClosestTarget` has
+  the same player-exclusion bug #298 fixed for graphical hosts.
+  MEDIUM.** `src/AcDream.Headless/Hosting/HeadlessGameplayOperations.cs:235-244`
+  checks explicit selection via `RuntimeHostileTargetQuery.IsHostile`
+  (`src/AcDream.Runtime/Gameplay/RuntimeHostileTargetQuery.cs:73-101`), which is
+  the monster-only `CombatTargetPolicy.IsHostileMonster` gate — structurally
+  identical to the bug #298 fixed in `CombatAttackTargetSource`/
+  `SelectionInteractionController`. A headless bot that explicitly selects a
+  compatible-PK player and attacks will fall through to `SelectClosestTarget()`
+  (since `AutoTarget` is hardcoded `true` at `:128`) instead of attacking the
+  selected player. Pre-existing (not introduced by #298 — confirmed by the
+  same `9966b531`/`3361a8d7`/`2644d1d5`/`0f2d98c5` diff boundary #297 used), but
+  the graphical/headless behavioral *divergence* is new as of the #298 commit,
+  and Slice K makes headless a first-class host, so the gap is now live for bot
+  PvP. Fix shape: same split as #298 — add an `ObjectIsAttackable`-backed
+  explicit-admission query to `RuntimeHostileTargetQuery` (or a sibling) and
+  route `GetSelectedOrClosestTarget`'s explicit branch through it, leaving
+  `FindClosest`/auto-acquisition on the narrow policy. Filed from the #298
+  review.
+
 ## C3c placement cutover — 2026-08-02
 
 - **#276 — OPEN — SpawnPlacementSettler discards the settle's resolved

docs/architecture/retail-divergence-register.md

@@ -56,7 +56,7 @@ accepted-divergence entries (#96, #49, #50).
 | IA-15 | D.2b gameplay UI is our own `UiHost`/`UiRoot` retained tree, not a byte-port of Keystone. `RetailUiRuntime` owns the production import/mount graph; `RetailWindowManager`/typed handles centralize registry, raise, focus/capture cleanup, lifecycle events, reverse-order grouped controller teardown, removable Silk input subscriptions, schema-v2 per-character/per-resolution automatic layouts with per-window authored-geometry revisions, and portable named `saveui/loadui` profiles; `RetailWindowFrame` is the single production/Studio mount contract for imported-chrome and shared-wrapper windows. Production LayoutDesc imports include vitals `0x2100006C`, chat `0x21000006`, toolbar `0x21000016`, character `0x2100002E`, inventory `0x21000023` plus mounted `0x21000024/22/21`, dialog catalog `0x2100003C`, radar `0x21000074`, and external container `0x21000008` (shared bevel plus a user-directed compact 700-pixel initial content width instead of its authored 800-pixel root). The dialog context/queue/callback lifecycle is now a named-client port; only its retained rendering remains under this Keystone adaptation. | `src/AcDream.App/UI/RetailUiRuntime.cs`; `src/AcDream.App/UI/RetailWindowManager.cs`; `src/AcDream.App/UI/RetainedPanelControllerGroup.cs`; `src/AcDream.App/UI/UiHost.cs`; `src/AcDream.App/UI/RetailWindowLayoutPersistence.cs`; `src/AcDream.App/UI/Layout/RetailWindowFrame.cs`; `src/AcDream.App/UI/Layout/RetailDialogFactory.cs`; `src/AcDream.App/UI/Layout/RetailConfirmationDialogView.cs`; `src/AcDream.App/UI/Layout/ExternalContainerController.cs`; `src/AcDream.App/UI/Layout/LayoutImporter.cs`; binding supply in `GameWindow.cs` | Keystone has no matching PDB/decomp, so we preserve its observable ElementDesc/state/input behavior from DAT, named client call sites, and live evidence while using modern retained ownership. Real RenderSurfaces and imported element geometry remain the visual oracle; the external strip's initial width follows the connected visual direction and remains horizontally resizable to its authored extent or the viewport edge. | Persistence and low-level widget rendering are behaviorally reconstructed from retail semantics rather than a Keystone byte-port; lifecycle edge cases remain constrained by conformance tests. The external strip opens 100 pixels narrower than the raw LayoutDesc before user/persistence resizing. | Production LayoutDesc objects; `DialogFactory @ 0x004773C0..0x00478470`; `gmExternalContainerUI @ 0x004CBAD0..0x004CBFE0`; `docs/research/2026-07-13-retail-dialog-factory-pseudocode.md`; Keystone behavior notes in `docs/research/retail-ui/` |
 | IA-17 | Toolbar chrome is toolkit-supplied through the central `RetailWindowFrame` mount (`UiCollapsibleFrame` 8-piece bevel) because LayoutDesc `0x21000016` carries no baked frame. It also supports a toolkit-defined collapse-to-one-row (bottom-edge resize snapping between a row-1-only and a two-row height, row-2 visibility tied to the stop) — retail's real collapse is keystone.dll (no decomp) and the DAT stacks both rows always. | `src/AcDream.App/UI/Layout/RetailWindowFrame.cs`; `src/AcDream.App/UI/UiCollapsibleFrame.cs`; toolbar policy in `GameWindow.cs`; spec: `docs/superpowers/specs/2026-06-20-d2b-toolbar-collapse-design.md` | The central mount now owns wrapper geometry/registration uniformly; border-over-content prevents the row-2 right cap from poking through | The collapse stops remain a toolkit reconstruction rather than a byte-port of Keystone behavior | gmToolbarUI WM chrome (keystone.dll, no PDB); no bevel ids in LayoutDesc 0x21000016 (toolbar dump) |
 | IA-18 | Effect overlay tile (enum 0x10000005) is a `ReplaceColor` SURFACE SOURCE — pure-white pixels in the composited drag icon are replaced PER-PIXEL with the same (x,y) pixel of the effect tile (the SURFACE overload `SurfaceWindow::ReplaceColor` 0x004415b0), preserving the tile's texture/gradient; the tile itself is NOT blitted as an additional layer. This IS faithful retail behavior. **Anti-regression: do NOT re-implement this as a blit layer NOR as a flat-color replace (it is a per-pixel surface copy).** | `src/AcDream.App/UI/IconComposer.cs` (`ReplaceWhiteFromSurface`) | Faithful port of `IconData::RenderIcons` @407614 → the SURFACE overload `ReplaceColor` 0x004415b0 (`dst[x,y]=src[x,y]` where `dst==white`); confirmed via clean Ghidra decompile + named decomp + visual (the Energy Crystal's blue is a gradient, 2026-06-17). | A blit-layer or flat-color re-implementation would show the wrong effect look (no gradient) — the visual-verification regression that retired the mean-color approximation | `IconData::RenderIcons` acclient_2013_pseudo_c.txt:407524; `ReplaceColor` SURFACE overload 0x004415b0:71656; `docs/research/2026-06-17-stateful-icon-RESOLVED.md` |
-| IA-19 | Automatic combat acquisition is narrowed to attackable non-player monsters. Retail `AutoTarget` falls back to `SelectNext(SELECTION_TYPE_COMPASS_ITEM)`, whose combat filter can also admit attackable enemy players in compatible PK states. | `src/AcDream.Core/Combat/CombatTargetPolicy.cs`; consumers `src/AcDream.App/Interaction/WorldSelectionQuery.cs` (`IsHostileMonster`/`FindClosestHostileMonster`) and `SelectionInteractionController.cs` (`SelectClosestCombatTarget`) | Explicit product direction: Auto Target must never select NPCs, players, pets, or other objects; manual player-selection commands remain available | In PK play, Auto Target will not acquire an otherwise valid hostile player as retail would; the player must be selected manually | `ClientCombatSystem::AutoTarget @ 0x0056BC80`; `CPlayerSystem::SelectNext @ 0x0055F9A0`; `ClientCombatSystem::ObjectIsAttackable @ 0x0056A600` |
+| IA-19 | Automatic combat acquisition is narrowed to attackable non-player monsters. Retail `AutoTarget` falls back to `SelectNext(SELECTION_TYPE_COMPASS_ITEM)`, whose combat filter can also admit attackable enemy players in compatible PK states. | `src/AcDream.Core/Combat/CombatTargetPolicy.cs`; consumers `src/AcDream.App/Interaction/WorldSelectionQuery.cs` (`IsHostileMonster`/`FindClosestHostileMonster`) and `SelectionInteractionController.cs` (`SelectClosestCombatTarget`). This row is auto-acquisition-only: as of #298, explicit-target admission and the combat camera route through the separate, retail-exact `WorldSelectionQuery.IsAttackableTarget` (`ObjectIsAttackable`-backed) instead, so a compatible-PK player is a valid manual attack/camera target — do not assume one predicate still serves both concerns. | Explicit product direction: Auto Target must never select NPCs, players, pets, or other objects; manual player-selection commands remain available | In PK play, Auto Target will not acquire an otherwise valid hostile player as retail would; the player must be selected manually | `ClientCombatSystem::AutoTarget @ 0x0056BC80`; `CPlayerSystem::SelectNext @ 0x0055F9A0`; `ClientCombatSystem::ObjectIsAttackable @ 0x0056A600` |
 | IA-20 | The basic combat bar keeps dark-red media `0x0600715E` visible as the centered middle baseline. Retail skill-gates field `0x100005EF` to trained Recklessness; the separate bright child remains faithful live `SetPowerbarLevel` feedback from the absolute left edge. | `src/AcDream.App/UI/UiScrollbar.cs`; child-policy extraction in `src/AcDream.App/UI/Layout/DatWidgetFactory.cs` | Explicit connected visual direction: the dark middle track remains present behind live attack charge; the exact skill-gated treatment remains tracked by AP-112 | Untrained characters retain the dark-red baseline where retail may leave only the gray track; trained/untrained Recklessness presentation is not distinguishable | `gmCombatUI::RecvNotice_SetPowerbarLevel @ 0x004CC0E0`; `gmCombatUI::ListenToElementMessage @ 0x004CC430`; LayoutDesc `0x21000073` |
 | IA-21 | When ACE sends player BoolProperty `68` (`SpellComponentsRequired`) false, acdream presents the retail scarab/prismatic-taper formula even without a directly carried school focus. With component enforcement enabled, retail's exact focus/infusion versus account-customized selection remains intact. | `src/AcDream.App/Spells/SpellComponentRequirementService.cs` | A component-disabled server has no actionable legacy recipe; explicit product direction is that this client/server mode uses the modern scarab/taper component presentation | A custom server could expect retail's legacy recipe to remain visible even though casting consumes no components | `ClientMagicSystem::AreSpellComponentsRequired @ 0x00567B90`; `ClientMagicSystem::GetAppropriateSpellFormula @ 0x00567D50`; `CSpellBase::InqScarabOnlyFormula @ 0x00597050` |