ModernUO/Projects/UOContent/Engines/Help/SpeechLogGump.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

130 lines
3.6 KiB
C#

using System;
using System.Collections.Generic;
using Server.Accounting;
using Server.Text;
using Server.Gumps;
using Server.Network;
namespace Server.Engines.Help
{
public class SpeechLogGump : Gump
{
public static readonly int MaxEntriesPerPage = 30;
private readonly List<SpeechLogEntry> m_Log;
private readonly int m_Page;
private readonly Mobile m_Player;
public SpeechLogGump(Mobile player, SpeechLog log)
: this(player, new List<SpeechLogEntry>(log))
{
}
public SpeechLogGump(Mobile player, List<SpeechLogEntry> log) : this(
player,
log,
(log.Count - 1) / MaxEntriesPerPage
)
{
}
public SpeechLogGump(Mobile player, List<SpeechLogEntry> log, int page)
: base(500, 30)
{
m_Player = player;
m_Log = log;
m_Page = page;
AddImageTiled(0, 0, 300, 425, 0xA40);
AddAlphaRegion(1, 1, 298, 423);
var playerName = player.Name;
var playerAccount = player.Account is Account ? player.Account.Username : "???";
AddHtml(
10,
10,
280,
20,
Html.Center($"SPEECH LOG - {playerName} (<i>{playerAccount.FixHtmlFormattable()}</i>)", 0xA0A0FF)
);
var lastPage = (log.Count - 1) / MaxEntriesPerPage;
string sLog;
if (page < 0 || page > lastPage)
{
sLog = "";
}
else
{
var max = log.Count - (lastPage - page) * MaxEntriesPerPage;
var min = Math.Max(max - MaxEntriesPerPage, 0);
using var builder = ValueStringBuilder.Create();
for (var i = min; i < max; i++)
{
var entry = log[i];
var m = entry.From;
var name = m.Name;
var account = m.Account is Account ? m.Account.Username : "???";
var speech = entry.Speech;
if (i != min)
{
builder.Append("<br>");
}
builder.Append($"<u>{name}</u> (<i>{account.FixHtml()}</i>): {speech.FixHtml()}");
}
sLog = builder.ToString();
}
AddHtml(10, 40, 280, 350, sLog, false, true);
if (page > 0)
{
AddButton(10, 395, 0xFAE, 0xFB0, 1); // Previous page
}
AddLabel(45, 395, 0x481, $"Current page: {page + 1}/{lastPage + 1}");
if (page < lastPage)
{
AddButton(261, 395, 0xFA5, 0xFA7, 2); // Next page
}
}
public override void OnResponse(NetState sender, in RelayInfo info)
{
var from = sender.Mobile;
switch (info.ButtonID)
{
case 1: // Previous page
{
if (m_Page - 1 >= 0)
{
from.SendGump(new SpeechLogGump(m_Player, m_Log, m_Page - 1));
}
break;
}
case 2: // Next page
{
if ((m_Page + 1) * MaxEntriesPerPage < m_Log.Count)
{
from.SendGump(new SpeechLogGump(m_Player, m_Log, m_Page + 1));
}
break;
}
}
}
}
}