erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions

fix(physics): #297 — keep the PWD bitfield live so PK status reaches the client

Browse source 
The user typed @pklite and then walked straight through other PKLite players.

Root cause: ClientObject.PublicWeenieBitfield was written exactly once, from the
0xF745 CreateObject parse, and never refreshed. ACE's only PK-change message is
PropertyInt.PlayerKillerStatus (134) over 0x02CE/0x02CD, which we parsed and
stored into Properties.Ints[134] but never translated back into the bitfield —
and ACE never re-sends a PublicWeenieDesc at all (EnqueueBroadcastUpdateObject
has zero live callers), so that property is the ONLY signal a client can learn
from. Both sides of the collision test read the frozen value, so
CollisionExemption's "4c. both PKLite -> collide" rule could never fire.

Retail's missing port: PublicWeenieDesc::SetPlayerKillerStatus @0x005AC7C0
rewrites _bitfield in place — PK(4) -> (b & 0xfddfffff) | 0x20; PKLite(0x40) ->
(b & 0xffdfffdf) | 0x2000000; Free(0x20) -> (b & 0xfdffffdf) | 0x200000; else
b &= 0xfddfffdf. Mutually exclusive, verified byte-for-byte, with input values
confirmed against retail's own PKStatusEnum (acclient.h:6412-6427), not just
ACE's. Driven from ACCWeenieObject::OnStatUpdated @0x0058DF20 case 0x86.

The fix rewrites the value at its source rather than patching consumers. Two
review rounds were needed because the first pass missed that there are TWO
snapshot stores: InboundPhysicsStateController keeps its own private _snapshots
dictionary, and every untimestamped-field merge (ApplyAcceptedObjDesc and
friends) reads `old` from THAT store, not from RuntimeEntityRecord.Snapshot.
Refreshing only the active record left the target-side shadow flags correct
until the remote's next equip or unequip — ACE broadcasts an ObjDesc on every
one — at which point the appearance path rebuilt the registration from the
frozen spawn and dropped the bit permanently. The regression test demanded by
review is what surfaced that; it is verified discriminating (reverting gives
Actual: 8 instead of 33554440).

Five stores now hold this value, kept coherent from one source by two
ObjectUpdated subscribers plus the appearance-rebuild path. The two shadow-flag
writers are the same invalidation applied at the two edges that can invalidate
it, not competing authorities — review enumerated every drift path and closed
each. That coherence invariant is new as of this commit and is recorded as
register row AP-134, with AP-133 as the precedent for filing a row when the
danger is a future writer rather than current behaviour.

Also corrects TS-23's retirement narrative, which claimed every mover-flags call
site read the mover's "real" PK bits from 2026-07-30. The bits existed but their
source was frozen, so that only became true here; the site enumeration also
missed RuntimeSetPositionMoverPreparation, a seventh site that decodes the
snapshot directly.

Unblocks #298 (melee/missile admission needs the local player's own PKLite bit).
Follow-ups filed: #300 (Properties.Ints[134] vs bitfield mirror gap), #301 (same
defect class for radar blip colour and radar behaviour), #302 (a pre-existing
PortalProjection allocation-assertion flake, 1 in 6, found while verifying this
gate), #303 (LiveEntityPvpBitfieldSync is App-resident but Runtime-owned-state).

Gates: complete Release solution 10,895 passed / 4 skipped / 0 failed (baseline
10,887 including #299). Adversarial + retail-conformance review PASS after one
FAIL round. Every new test discrimination-verified by reverting the fix.
Connected acceptance NOT run — needs a live two-client PKLite session.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-08-03 20:59:01 +02:00
parent 88348f6791
commit 9b1e6fc637
19 changed files with 1329 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

110
tests/AcDream.Core.Tests/Physics/ShadowObjectRegistryTests.cs
View file

@ -202,6 +202,116 @@ public class ShadowObjectRegistryTests
Assert.Equal(0x44u, restored.State);
}
// -----------------------------------------------------------------------
// UpdatePwdBitfieldFlags (#297 target-side refresh)
// -----------------------------------------------------------------------
[Fact]
public void UpdatePwdBitfieldFlags_ReplacesOnlyPwdDerivedBits()
{
// Simulates CreateObject-time registration (IsPlayer decoded from the
// spawn bitfield, IsCreature derived from ItemType, HasWeenie set by
// the builder) followed by a live PropertyInt(PlayerKillerStatus)
// arrival that goes PKLite. IsCreature/HasWeenie must survive
// untouched; IsPlayer must survive because the new bitfield still
// carries BF_PLAYER.
var reg = new ShadowObjectRegistry();
const uint entityId = 60u;
reg.Register(
entityId,
0x01000005u,
new Vector3(12f, 12f, 50f),
Quaternion.Identity,
1f,
OffX,
OffY,
LbId,
flags: EntityCollisionFlags.HasWeenie
| EntityCollisionFlags.IsCreature
| EntityCollisionFlags.IsPlayer,
seedCellId: LbId | 1u);
reg.UpdatePwdBitfieldFlags(entityId, pwdBitfield: 0x2000008u); // BF_PLAYER | PKLite
ShadowEntry entry = Assert.Single(reg.GetObjectsInCell(LbId | 1u));
Assert.Equal(
EntityCollisionFlags.HasWeenie
| EntityCollisionFlags.IsCreature
| EntityCollisionFlags.IsPlayer
| EntityCollisionFlags.IsPKLite,
entry.Flags);
}
[Fact]
public void UpdatePwdBitfieldFlags_ClearsStalePkStateWhenBitfieldNoLongerCarriesIt()
{
var reg = new ShadowObjectRegistry();
const uint entityId = 61u;
reg.Register(
entityId,
0x01000005u,
new Vector3(12f, 12f, 50f),
Quaternion.Identity,
1f,
OffX,
OffY,
LbId,
flags: EntityCollisionFlags.HasWeenie
| EntityCollisionFlags.IsPlayer
| EntityCollisionFlags.IsPKLite,
seedCellId: LbId | 1u);
// Target reverts to NPK — bitfield no longer carries the PKLite bit.
reg.UpdatePwdBitfieldFlags(entityId, pwdBitfield: 0x8u); // BF_PLAYER only
ShadowEntry entry = Assert.Single(reg.GetObjectsInCell(LbId | 1u));
Assert.Equal(
EntityCollisionFlags.HasWeenie | EntityCollisionFlags.IsPlayer,
entry.Flags);
}
[Fact]
public void UpdatePwdBitfieldFlags_UnregisteredEntity_NoOp()
{
var reg = new ShadowObjectRegistry();
// Must not throw for an entity with no live shadow registration
// (e.g. an off-screen/never-materialized object).
reg.UpdatePwdBitfieldFlags(999u, pwdBitfield: 0x2000000u);
Assert.Equal(0, reg.TotalRegistered);
}
[Fact]
public void UpdatePwdBitfieldFlags_ThenCollisionExemption_BothPkLiteNowCollide()
{
// End-to-end #297 payoff: a target registered at spawn as a plain
// (non-PK) player, then a live PropertyInt(PlayerKillerStatus)
// update makes it PKLite. Before the target-side refresh existed,
// CollisionExemption would keep reading the frozen spawn-time
// flags and the pair would walk through each other forever.
var reg = new ShadowObjectRegistry();
const uint entityId = 62u;
reg.Register(
entityId,
0x01000005u,
new Vector3(12f, 12f, 50f),
Quaternion.Identity,
1f,
OffX,
OffY,
LbId,
flags: EntityCollisionFlags.HasWeenie | EntityCollisionFlags.IsPlayer,
seedCellId: LbId | 1u);
var moverState = ObjectInfoState.IsPlayer | ObjectInfoState.IsPKLite;
ShadowEntry before = Assert.Single(reg.GetObjectsInCell(LbId | 1u));
Assert.True(CollisionExemption.ShouldSkip(before.State, before.Flags, moverState));
reg.UpdatePwdBitfieldFlags(entityId, pwdBitfield: 0x2000008u); // BF_PLAYER | PKLite
ShadowEntry after = Assert.Single(reg.GetObjectsInCell(LbId | 1u));
Assert.False(CollisionExemption.ShouldSkip(after.State, after.Flags, moverState));
}
[Fact]
public void ReplaceMultiPartPayload_VisibleOwnerKeepsExistingCellMembership()
{