ModernUO/Projects/UOContent/Skills/ForensicEval.cs
Kamron Batman 61e41df00c
feat: Add zero-alloc interpolation handler to ValueStringBuilder, replace all StringBuilder usage (#2387)
## Summary

- **Add a self-referencing `InterpolationHandler` to `ValueStringBuilder`** that writes directly into the builder's buffer — zero intermediate allocation, works with `stackalloc`-backed builders
- **Replace all `System.Text.StringBuilder` usage** across the codebase with `ValueStringBuilder`
- **Convert `ValueStringBuilder.Create()` to `stackalloc`** at 10 sites where output length is provably bounded
- **Convert manual `Dispose()` to `using var`** where possible, and hoist loop-scoped builders outside loops with `Reset()`
- **Convert verbose `Append()` chains to `Append($"...")`** interpolation for readability
- **Add comprehensive documentation** for string handling patterns

## InterpolationHandler Design

`ValueStringBuilder` is a `ref struct`, which creates challenges for C#'s interpolated string handler pattern:

- **`ref` fields to ref structs are not allowed** (CS9050)
- **`[InterpolatedStringHandlerArgument("")]` passes struct receivers by value**, not by ref
- **`ISelfInterpolatedStringHandler` requires boxing** ref structs into interface fields

**Solution: Copy-and-reconcile pattern.** The handler receives a value copy of the builder. The copy shares the same underlying `char` buffer (`Span` points to the same `stackalloc`/pooled memory), so writes go to the original buffer. `Append()` reconciles by `this = handler._builder`, updating `_length` and any buffer references changed by `Grow()`.

This is safe because:
- The game loop is single-threaded — no concurrent access between handler construction and reconciliation
- If `Grow()` occurs in the copy, the original's stale buffer isn't accessed until `Append()` replaces it
- `Dispose()` correctly returns the reconciled buffer to the pool

## Changes by Category

### ValueStringBuilder (`Projects/Server/Buffers/ValueStringBuilder.cs`)
- Added nested `InterpolationHandler` ref struct with copy-and-reconcile pattern
- Added `Append([InterpolatedStringHandlerArgument("")] scoped ref InterpolationHandler)` method
- Removed `RawInterpolatedStringHandler` overloads (new handler replaces them)
- All `AppendFormatted` overloads delegate to existing `Append` methods (no code duplication)
- Alignment support via direct private field access (nested type privilege)

### StringBuilder → ValueStringBuilder (15 files)
Replaced all `new StringBuilder()` with `ValueStringBuilder.Create()` or `stackalloc`:
- ConPVP games: KingOfTheHill, DoubleDom, CTF, BombingRun, TourneyMatch
- ConPVP infrastructure: Tournament, Participant, TourneyParticipant
- ConPVP gumps: ArenaGump, TournamentBracketGump, AcceptTeamGump, ConfirmSignupGump
- Commands: Handlers, Logging, Add
- Other: TownCrier, SpeechLogGump, TestCenter

Key patterns:
- `sb = new StringBuilder()` reassignment → `sb.Reset()`
- `sb.AppendFormat("{0:N0}", value)` → `sb.Append($"{value:N0}")`
- `sb.Append(x).Append(y)` chains → separate statements (VSB returns void)

### Create() → stackalloc (10 files)
Converted heap-allocated builders to stackalloc where output is bounded:
- ClientVersion (32), MapSelection (160), HouseRaffleStone (48)
- HolySense (96), UnholySense (96), ClientVerification (192)
- AcceptTeamGump (64), ConfirmSignupGump (64)
- BaseWeapon (160), BaseArmor (128)

### Loop optimizations (2 files)
Hoisted `ValueStringBuilder` creation outside loops with `Reset()` per iteration:
- TourneyMatch.cs: `using var` inside for loop → stackalloc before loop
- ArenaGump.cs: `Create()` + `Dispose()` per iteration → stackalloc before loop

### Append chain → interpolation (5 files)
Converted multi-line `Append()` chains to `Append($"...")`:
- BountyMessage.cs: title switch (6 cases), paragraph (15→1 Append), description lines, closing
- AcceptTeamGump, ConfirmSignupGump, TournamentBracketGump: tournament type strings
- AdminGump: comment/tag formatting in loops

### Documentation
- `dev-docs/string-handling.md`: Full reference — construction, interpolation, disposal, decision guide
- `dev-docs/claude-skills/modernuo-string-handling.md`: Claude skill with quick reference
- `CLAUDE.md`: Added rule 17 (no StringBuilder), dev-docs table entry, skills table entry
- `dev-docs/code-standards.md`: Updated memory management section

## Test Plan

- [x] `dotnet build` — 0 errors, 0 warnings
- [x] `dotnet test` — 940/940 tests pass
- [x] 28 ValueStringBuilder tests covering all reconciliation scenarios:
  - Stackalloc no-grow, stackalloc with grow (→pool transition)
  - Heap no-grow, heap with grow, heap double grow
  - Pre-existing content with and without grow
  - Sequential multiple `Append($"...")` calls
  - Mixed plain + interpolated Append
  - Empty interpolation, literal-only, format specifiers
  - Null string holes, ISpanFormattable types
  - Dispose after stackalloc→pool grow
2026-03-22 14:23:44 -07:00

121 lines
4.3 KiB
C#

using System;
using Server.Items;
using Server.Mobiles;
using Server.Targeting;
using Server.Text;
namespace Server.SkillHandlers
{
public static class ForensicEvaluation
{
public static void Initialize()
{
SkillInfo.Table[(int)SkillName.Forensics].Callback = OnUse;
}
public static TimeSpan OnUse(Mobile m)
{
m.Target = new ForensicTarget();
m.RevealingAction();
m.SendLocalizedMessage(501000); // Show me the crime.
return TimeSpan.FromSeconds(1.0);
}
public class ForensicTarget : Target
{
public ForensicTarget() : base(10, false, TargetFlags.None)
{
}
protected override void OnTarget(Mobile from, object target)
{
if (target is Mobile)
{
if (from.CheckTargetSkill(SkillName.Forensics, target, 40.0, 100.0))
{
if (target is PlayerMobile pm && pm.NpcGuild == NpcGuild.ThievesGuild)
{
from.SendLocalizedMessage(501004); // That individual is a thief!
}
else
{
from.SendLocalizedMessage(501003); // You notice nothing unusual.
}
}
else
{
from.SendLocalizedMessage(501001); // You cannot determine anything useful.
}
}
else if (target is Corpse c)
{
if (from.CheckTargetSkill(SkillName.Forensics, c, 0.0, 100.0))
{
if (c.Forensicist != null)
{
// The forensicist ~1_NAME~ has already discovered that:
from.SendLocalizedMessage(1042750, c.Forensicist);
}
else
{
c.Forensicist = from.Name;
}
if (((Body)c.Amount).IsHuman)
{
// This person was killed by ~1_KILLER_NAME~
from.SendLocalizedMessage(1042751, c.Killer == null ? "no one" : c.Killer.Name);
}
if (c.Looters.Count > 0)
{
using var sb = new ValueStringBuilder(stackalloc char[128]);
var i = 0;
foreach (var looter in c.Looters)
{
if (i == c.Looters.Count - 1)
{
sb.Append($", and {looter.Name}");
}
else if (i > 0)
{
sb.Append($", {looter.Name}");
}
else
{
sb.Append(looter.Name);
}
i++;
}
// This body has been disturbed by ~1_PLAYER_NAMES~
from.SendLocalizedMessage(1042752, sb.ToString());
}
else
{
from.SendLocalizedMessage(501002); // The corpse has not be desecrated.
}
}
else
{
from.SendLocalizedMessage(501001); // You cannot determine anything useful.
}
}
else if (target is ILockpickable p)
{
if (p.Picker != null)
{
from.SendLocalizedMessage(1042749, p.Picker.Name); // This lock was opened by ~1_PICKER_NAME~
}
else
{
from.SendLocalizedMessage(501003); // You notice nothing unusual.
}
}
}
}
}
}