fix: Removes side effects from locked down items, decaying houses, bracelet of binding, and builds (#2608)

## Why

Delta world saves (only changed entities re-serialized during the freeze) need two things from content: `Serialize` must be pure, and an unchanged entity must produce identical bytes on every save. An audit of the tree found the places that break this today. This PR fixes them and adds a diagnostic that measures byte stability in a running world over real time. No wire format changes, no version bumps.

## What

- **Guild**: `Serialize` ran the daily guildmaster recalculation (dictionary-order tie breaks, random picks, mutates another entity), war expiry, and the alliance leadership check on every save. That work now runs from `GuildMaintenanceTimer` (the former `WarTimer`, now started for both guild systems; the war and alliance checks are no-ops without the new guild system).
- **BaseHouse**: the `DecayLevel` getter wrote `LastRefreshed` and advanced the dynamic decay stage on every read, so any undecayable house changed its persisted bytes whenever a sign, gump, or `[Props` looked at it. It is now a pure read; `UpdateDecay()` on the decay tick advances the stage and refreshes a house that leaves the undecayable state.
- **Locked-down container contents decay through `DecayScheduler`** instead of a sweep inside `BaseHouse.Serialize`. `Item.CanDecay` now accepts a parent container whose new `Container.ContentsDecay` is true (locked down and not secure) when the content item is not itself locked down or secured; the `IsLockedDown`/`IsSecure` setters re-evaluate a container and its direct contents; `OnDecay` resolves the region from the world location. `BaseBoard`, `Aquarium` and `FishBowl` override `ContentsDecay` to false, matching the exclusions of the old sweep. Items already inside such containers are picked up at load, where every item re-evaluates its registration. The per-save O(all locked-down items) walk is gone; the work is now event driven.
- **BraceletOfBinding**: the `Bound` getter nulled its backing field for a deleted target; it now returns null for a missing or deleted target without writing.
- **`[SaveStability [delaySeconds=60] [sampleStride=1]`** (Administrator): hashes the serialized bytes of every entity in every registered entity persistence (`Persistence.EntityPersistences`, new), waits the delay in real time, hashes again, and reports per type how many records changed. Both passes are chunked under a 20 ms per-tick budget. Serializing twice inside one tick cannot see drift derived from `Core.Now`, which is frozen within a tick; the real-time wait is the point. On an idle shard the only legitimate churn is NPC movement and regeneration, so a static type with a high changed fraction is a serialization bug. `[SaveStability cancel` stops a run.

Engine additions: `Container.ContentsDecay` / `UpdateContentsDecayRegistration()`, the `CanDecay`/`OnDecay` change above, and diagnostic-facing `IGenericEntityPersistence.Name`, `EntityCount`, `EnumerateEntities()`, and `Persistence.EntityPersistences`.

## Behaviour notes

- Fealty recalculation now happens on the minute timer for both guild systems instead of at save time.
- A house that becomes decayable is refreshed on its next decay tick rather than at the exact moment of transition (at most one minute later).
- Contents of locked-down containers now decay on their own schedule (same `LastMoved + DecayTime` rule) instead of at the next world save after becoming due.

## Testing

- New tests: `GuildSerializePurityTests`, `HouseDecayPurityTests`, `SaveStabilityTests` (stable entities hash identically after the clock advances; a clock-stamped record is reported by type only after the clock advances; the snapshot covers Items, Mobiles and Guilds).
- `LockedDownContainerDecayTests` (Server.Tests): registration on drop, lock/secure/release transitions, excluded containers, nested containers, and decay on schedule through the scheduler.
- Full suites: Server.Tests 855 passed, UOContent.Tests 765 passed.
This commit is contained in:
Kamron Batman 2026-09-06 09:39:00 -07:00 • committed by GitHub
parent e52d54b7da
commit a2c232f4a8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
15 changed files with 921 additions and 67 deletions

View file

@ -31,6 +31,7 @@ namespace Server.Multis
private DecayLevel m_CurrentStage;
private DecayLevel m_LastDecayLevel;
private bool _wasUndecayable; // not serialized: decay tick state only
private Mobile m_Owner;
@ -198,19 +199,58 @@ namespace Server.Multis
{
get
{
DecayLevel result;
if (!CanDecay)
{
return DecayLevel.Ageless;
}
if (DynamicDecay.Enabled)
{
var stage = m_CurrentStage;
if (stage == DecayLevel.Collapsed && (HasRentedVendors || VendorInventories.Count > 0))
{
return DecayLevel.DemolitionPending;
}
return stage;
}
return GetOldDecayLevel();
}
}
/// <summary>
/// Advances decay bookkeeping. Runs from the decay tick, never from a read: a getter that
/// writes persisted fields makes every house record change on every read.
/// </summary>
public virtual void UpdateDecay()
{
if (!CanDecay)
{
if (DynamicDecay.Enabled && m_CurrentStage != DecayLevel.Ageless)
{
ResetDynamicDecay();
}
_wasUndecayable = true;
}
else
{
if (_wasUndecayable)
{
// Leaving the undecayable state counts as a refresh, which the old getter
// guaranteed by restamping LastRefreshed on every read while undecayable.
_wasUndecayable = false;
LastRefreshed = Core.Now;
if (DynamicDecay.Enabled)
{
ResetDynamicDecay();
}
LastRefreshed = Core.Now;
result = DecayLevel.Ageless;
}
else if (DynamicDecay.Enabled)
if (DynamicDecay.Enabled)
{
var stage = m_CurrentStage;
@ -218,32 +258,19 @@ namespace Server.Multis
{
SetDynamicDecay(++stage);
}
if (stage == DecayLevel.Collapsed && (HasRentedVendors || VendorInventories.Count > 0))
{
result = DecayLevel.DemolitionPending;
}
else
{
result = stage;
}
}
else
}
var level = DecayLevel;
if (level != m_LastDecayLevel)
{
m_LastDecayLevel = level;
if (Sign?.GettingProperties == false)
{
result = GetOldDecayLevel();
Sign.InvalidateProperties();
}
if (result != m_LastDecayLevel)
{
m_LastDecayLevel = result;
if (Sign?.GettingProperties == false)
{
Sign.InvalidateProperties();
}
}
return result;
}
}
@ -582,6 +609,7 @@ namespace Server.Multis
return false;
}
UpdateDecay();
var oldLevel = DecayLevel;
LastRefreshed = Core.Now;
@ -598,6 +626,8 @@ namespace Server.Multis
public virtual bool CheckDecay()
{
UpdateDecay();
if (!Deleted && DecayLevel == DecayLevel.Collapsed)
{
Timer.StartTimer(Decay_Sandbox);
@ -2969,28 +2999,6 @@ namespace Server.Multis
writer.Write(MaxLockDowns);
writer.Write(MaxSecures);
// Items in locked down containers that aren't locked down themselves must decay!
for (var i = 0; i < LockDowns.Count; ++i)
{
var item = LockDowns[i];
if (item is Container cont && !(cont is BaseBoard or Aquarium or FishBowl))
{
var children = cont.Items;
for (var j = 0; j < children.Count; ++j)
{
var child = children[j];
if (child.Decays && !child.IsLockedDown && !child.IsSecure &&
child.LastMoved + child.DecayTime <= Core.Now)
{
Timer.StartTimer(child.Delete);
}
}
}
}
}
public override void Deserialize(IGenericReader reader)