## What `Dictionary<K,V>.Remove` and `HashSet<T>.Remove` do not bump the collection's version, so removing an entry during a `foreach` does not invalidate the enumerator. A number of loops were still paying for a `PooledRefQueue`/`PooledRefList` to collect keys and drain them in a second pass. This drops those guards. ## Why it's safe Verified against .NET 10.0.10 rather than taken on trust, since the documented guarantee covers only `Dictionary<TKey,TValue>.Remove` while several of these call sites are `HashSet<T>` or enumerate `.Keys`/`.Values`: | Case | Result | |---|---| | `Dictionary` foreach + `Remove` | safe, all entries visited | | `Dictionary.Keys` / `.Values` foreach + `Remove` | safe, all entries visited | | `HashSet` foreach + `Remove` | safe, all entries visited | | `Dictionary` foreach + `Remove` **then `Add`** | throws `InvalidOperationException` | Reflection on `_version` confirms the mechanism: neither `Dictionary.Remove` nor `HashSet.Remove` touches it. Because `Remove` never bumps the version, the `Keys` and `Values` enumerators are just as safe as the dictionary's own, even though only `Dictionary.Remove` documents the behaviour. No entries were skipped in any case. The `HashSet` half is confirmed by [stephentoub on dotnet/dotnet-api-docs#8177](https://github.com/dotnet/dotnet-api-docs/issues/8177#issuecomment-1167251052): *"Both HashSet and Dictionary have been improved to support removal during enumeration. The docs may just benefit from updating."* The gap is in the documentation, not the runtime. `Remove` followed by `Add` in the same enumeration still throws. That is the line this PR does not cross. ## Guards removed `VisibilityList`, `ChampionTitleSystem`, `Channel`, `BombingRun`, `Ruleset`, `PuzzleChest`, `RaceChangeGump`, `StepCache`, `PlayerMurderSystem`, `VirtueSystem`, `ProjectedItem`, `StaminaSystem`, `AIGroupMovement`, `PromotedGuard`, `AutoDenylist`, `LoginAllowlist`, `AntiMacroSystem`, `DetectHidden`. Both collection kinds are covered: `Dictionary` (including loops over `.Keys` and `.Values`) and `HashSet` (`ProjectedItem._active`, `PlayerMurderSystem._contextTerms`, `StaminaSystem._resetHash`). In `StaminaSystem.ResetTimer` the `Count == queue.Count → Clear()` branch goes away with the queue — it only existed to avoid paying for N individual removes. Where the collection supports it, `Contains` + `Remove` and `TryGetValue` + `Remove` also collapse into a single lookup (`if (list.Remove(x))`, `if (m_Pending.Remove(ns, out var state))`). `Utility.Tidy<K,V>` keeps its two branches: when `K` is serializable the value is not inspected, otherwise the value is. Only the serializable side may be cast, so `Dictionary<Mobile, int>` and `Dictionary<Mobile, string>` stay valid. ## Deliberately unchanged **`BaseCreature.LoyaltyTimer.OnTick`** keeps its deferred-delete queue. Removing from `World.Mobiles` while enumerating it is safe, but `Mobile.Delete()` is not a `Remove` — it runs `OnDelete`/`OnAfterDelete`, the `OnParentDeleted` cascade over the creature's pack, `DropHolding()`, and region and guild callbacks. Anything in that surface that constructs a `Mobile` is an `Add` into the dictionary being enumerated, which does invalidate it. `BaseHire.PayTimer.OnTick` has the same shape and is likewise untouched. **Spatial-query buffers** — `GuardedRegion.CallGuards`, `Thunderstorm`, `Exorcism`, `LeverPuzzleController`, `BaseCreature.TeleportPets` — are a different hazard. They buffer the result of a range query because the drain moves or harms mobiles, which mutates sectors mid-enumeration. **Re-entrant drains.** The `_users` sets in `Firebomb` and the explosion, conflagration and confusion-blast potions look like this pattern but are not: the loop collects, `Clear()`s, and only then runs `Target.Cancel` on each, which can re-enter. `AnimalTrainer` enumerates `pm.Stabled` and drains through `RemoveStabled`, which nulls the `Stabled` field once it empties — safe for an in-flight enumerator, which holds the set reference rather than the field, but subtle enough not to be worth inlining on a cold path. ## Verification `dotnet build` clean with 0 warnings; 810 Server and 684 UOContent tests pass.
152 lines
5.3 KiB
C#
152 lines
5.3 KiB
C#
using System.Collections.Generic;
|
|
using ModernUO.CodeGeneratedEvents;
|
|
using Server.Mobiles;
|
|
using Server.Network;
|
|
using Server.Targeting;
|
|
|
|
namespace Server.Commands
|
|
{
|
|
public static class VisibilityList
|
|
{
|
|
public static void Configure()
|
|
{
|
|
CommandSystem.Register("Vis", AccessLevel.Counselor, Vis_OnCommand);
|
|
CommandSystem.Register("VisList", AccessLevel.Counselor, VisList_OnCommand);
|
|
CommandSystem.Register("VisClear", AccessLevel.Counselor, VisClear_OnCommand);
|
|
}
|
|
|
|
[OnEvent(nameof(PlayerMobile.PlayerLoginEvent))]
|
|
public static void OnLogin(PlayerMobile pm) => pm.VisibilityList.Clear();
|
|
|
|
[Usage("Vis")]
|
|
[Description("Adds or removes a targeted player from your visibility list. Anyone on your visibility list will be able to see you at all times, even when you're hidden.")]
|
|
public static void Vis_OnCommand(CommandEventArgs e)
|
|
{
|
|
if (e.Mobile is PlayerMobile)
|
|
{
|
|
e.Mobile.Target = new VisTarget();
|
|
e.Mobile.SendMessage("Select person to add or remove from your visibility list.");
|
|
}
|
|
}
|
|
|
|
[Usage("VisList")]
|
|
[Description("Shows the names of everyone in your visibility list.")]
|
|
public static void VisList_OnCommand(CommandEventArgs e)
|
|
{
|
|
if (e.Mobile is PlayerMobile pm)
|
|
{
|
|
var list = pm.VisibilityList;
|
|
|
|
if (list.Count > 0)
|
|
{
|
|
if (list.Count == 1)
|
|
{
|
|
pm.SendMessage($"You are visible to {list.Count} mobile:");
|
|
}
|
|
else
|
|
{
|
|
pm.SendMessage($"You are visible to {list.Count} mobiles:");
|
|
}
|
|
|
|
for (var i = 0; i < list.Count; ++i)
|
|
{
|
|
pm.SendMessage($"#{i + 1}: {list[i].Name}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pm.SendMessage("Your visibility list is empty.");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Usage("VisClear")]
|
|
[Description("Removes everyone from your visibility list.")]
|
|
public static void VisClear_OnCommand(CommandEventArgs e)
|
|
{
|
|
if (e.Mobile is PlayerMobile pm)
|
|
{
|
|
var list = new List<Mobile>(pm.VisibilityList);
|
|
|
|
pm.VisibilityList.Clear();
|
|
pm.SendMessage("Your visibility list has been cleared.");
|
|
|
|
if (list.Count > 0)
|
|
{
|
|
var removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();
|
|
|
|
for (var i = 0; i < list.Count; ++i)
|
|
{
|
|
var m = list[i];
|
|
|
|
if (!m.CanSee(pm) && Utility.InUpdateRange(m.Location, pm.Location))
|
|
{
|
|
OutgoingEntityPackets.CreateRemoveEntity(removeEntity, pm.Serial);
|
|
m.NetState?.Send(removeEntity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class VisTarget : Target
|
|
{
|
|
public VisTarget() : base(-1, false, TargetFlags.None)
|
|
{
|
|
}
|
|
|
|
protected override void OnTarget(Mobile from, object targeted)
|
|
{
|
|
if (from is PlayerMobile pm && targeted is Mobile targ)
|
|
{
|
|
if (targ.AccessLevel <= pm.AccessLevel)
|
|
{
|
|
var list = pm.VisibilityList;
|
|
|
|
if (list.Remove(targ))
|
|
{
|
|
pm.SendMessage($"{targ.Name} has been removed from your visibility list.");
|
|
}
|
|
else
|
|
{
|
|
list.Add(targ);
|
|
pm.SendMessage($"{targ.Name} has been added to your visibility list.");
|
|
}
|
|
|
|
if (Utility.InUpdateRange(targ.Location, from.Location))
|
|
{
|
|
var ns = targ.NetState;
|
|
|
|
if (ns != null)
|
|
{
|
|
if (targ.CanSee(pm))
|
|
{
|
|
ns.SendMobileIncoming(targ, pm);
|
|
|
|
pm.SendOPLPacketTo(ns);
|
|
|
|
foreach (var item in pm.Items)
|
|
{
|
|
item.SendOPLPacketTo(ns);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ns.SendRemoveEntity(pm.Serial);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pm.SendMessage("They can already see you!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("Add only mobiles to your visibility list.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|