61e41df00c
## 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
1048 lines
43 KiB
C#
1048 lines
43 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Server.Gumps;
|
|
using Server.Mobiles;
|
|
using Server.Network;
|
|
using Server.Text;
|
|
|
|
namespace Server.Engines.ConPVP
|
|
{
|
|
public enum TourneyBracketGumpType
|
|
{
|
|
Index,
|
|
Rules_Info,
|
|
Participant_List,
|
|
Participant_Info,
|
|
Round_List,
|
|
Round_Info,
|
|
Match_Info,
|
|
Player_Info
|
|
}
|
|
|
|
public class TournamentBracketGump : Gump
|
|
{
|
|
private const int BlackColor32 = 0x000008;
|
|
private readonly Mobile m_From;
|
|
private List<object> m_List;
|
|
private readonly object m_Object;
|
|
private readonly int m_Page;
|
|
private readonly Tournament m_Tournament;
|
|
private readonly TourneyBracketGumpType m_Type;
|
|
private int m_PerPage;
|
|
|
|
public TournamentBracketGump(
|
|
Mobile from, Tournament tourney, TourneyBracketGumpType type,
|
|
List<object> list = null, int page = 0, object obj = null
|
|
) : base(50, 50)
|
|
{
|
|
m_From = from;
|
|
m_Tournament = tourney;
|
|
m_Type = type;
|
|
m_List = list;
|
|
m_Page = page;
|
|
m_Object = obj;
|
|
m_PerPage = 12;
|
|
|
|
switch (type)
|
|
{
|
|
case TourneyBracketGumpType.Index:
|
|
{
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 300, 9380);
|
|
|
|
using var sb = ValueStringBuilder.Create(128);
|
|
|
|
if (tourney.TourneyType == TourneyType.FreeForAll)
|
|
{
|
|
sb.Append("FFA");
|
|
}
|
|
else if (tourney.TourneyType == TourneyType.RandomTeam)
|
|
{
|
|
sb.Append($"{tourney.ParticipantsPerMatch}-Team");
|
|
}
|
|
else if (tourney.TourneyType == TourneyType.RedVsBlue)
|
|
{
|
|
sb.Append("Red v Blue");
|
|
}
|
|
else if (tourney.TourneyType == TourneyType.Faction)
|
|
{
|
|
sb.Append($"{tourney.ParticipantsPerMatch}-Team Faction");
|
|
}
|
|
else
|
|
{
|
|
for (var i = 0; i < tourney.ParticipantsPerMatch; ++i)
|
|
{
|
|
if (sb.Length > 0)
|
|
{
|
|
sb.Append('v');
|
|
}
|
|
|
|
sb.Append(tourney.PlayersPerParticipant);
|
|
}
|
|
}
|
|
|
|
if (tourney.EventController != null)
|
|
{
|
|
sb.Append($" {tourney.EventController.Title}");
|
|
}
|
|
|
|
sb.Append(" Tournament Bracket");
|
|
|
|
AddHtml(25, 35, 250, 20, sb.AsSpan().Center());
|
|
|
|
AddRightArrow(25, 53, ToButtonID(0, 4), "Rules");
|
|
AddRightArrow(25, 71, ToButtonID(0, 1), "Participants");
|
|
|
|
if (m_Tournament.Stage == TournamentStage.Signup)
|
|
{
|
|
var until = m_Tournament.SignupStart + m_Tournament.SignupPeriod - Core.Now;
|
|
string text;
|
|
var secs = (int)Math.Round(until.TotalSeconds);
|
|
|
|
if (secs > 0)
|
|
{
|
|
var mins = Math.DivRem(secs, 60, out secs);
|
|
|
|
if (mins > 0 && secs > 0)
|
|
{
|
|
text =
|
|
$"The tournament will begin in {mins} minute{(mins == 1 ? "" : "s")} and {secs} second{(secs == 1 ? "" : "s")}.";
|
|
}
|
|
else if (mins > 0)
|
|
{
|
|
text = $"The tournament will begin in {mins} minute{(mins == 1 ? "" : "s")}.";
|
|
}
|
|
else if (secs > 0)
|
|
{
|
|
text = $"The tournament will begin in {secs} second{(secs == 1 ? "" : "s")}.";
|
|
}
|
|
else
|
|
{
|
|
text = "The tournament will begin shortly.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
text = "The tournament will begin shortly.";
|
|
}
|
|
|
|
AddHtml(25, 92, 250, 40, text);
|
|
}
|
|
else
|
|
{
|
|
AddRightArrow(25, 89, ToButtonID(0, 2), "Rounds");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Rules_Info:
|
|
{
|
|
var ruleset = tourney.Ruleset;
|
|
var basedef = ruleset.Base;
|
|
|
|
BitArray defs;
|
|
|
|
if (ruleset.Flavors.Count > 0)
|
|
{
|
|
defs = new BitArray(basedef.Options);
|
|
|
|
for (var i = 0; i < ruleset.Flavors.Count; ++i)
|
|
{
|
|
defs.Or(ruleset.Flavors[i].Options);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
defs = basedef.Options;
|
|
}
|
|
|
|
var changes = 0;
|
|
|
|
var opts = ruleset.Options;
|
|
|
|
for (var i = 0; i < opts.Length; ++i)
|
|
{
|
|
if (defs[i] != opts[i])
|
|
{
|
|
++changes;
|
|
}
|
|
}
|
|
|
|
AddPage(0);
|
|
AddBackground(
|
|
0,
|
|
0,
|
|
300,
|
|
60 + 18 + 20 + 20 + 20 + 8 + 20 + ruleset.Flavors.Count * 18 + 4 + 20 + changes * 22 + 6,
|
|
9380
|
|
);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 0));
|
|
AddHtml(25, 35, 250, 20, "Rules".Center());
|
|
|
|
var y = 53;
|
|
|
|
var groupText = tourney.GroupType switch
|
|
{
|
|
GroupingType.HighVsLow => "High vs Low",
|
|
GroupingType.Nearest => "Closest opponent",
|
|
GroupingType.Random => "Random",
|
|
_ => null
|
|
};
|
|
|
|
AddHtml(35, y, 190, 20, $"Grouping: {groupText}");
|
|
y += 20;
|
|
|
|
var tieText = tourney.TieType switch
|
|
{
|
|
TieType.Random => "Random",
|
|
TieType.Highest => "Highest advances",
|
|
TieType.Lowest => "Lowest advances",
|
|
TieType.FullAdvancement => tourney.ParticipantsPerMatch == 2
|
|
? "Both advance"
|
|
: "Everyone advances",
|
|
TieType.FullElimination => tourney.ParticipantsPerMatch == 2
|
|
? "Both eliminated"
|
|
: "Everyone eliminated",
|
|
_ => null
|
|
};
|
|
|
|
AddHtml(35, y, 190, 20, $"Tiebreaker: {tieText}");
|
|
y += 20;
|
|
|
|
string sdText;
|
|
|
|
if (tourney.SuddenDeath > TimeSpan.Zero)
|
|
{
|
|
sdText = tourney.SuddenDeathRounds > 0 ?
|
|
$"Sudden Death: {(int)tourney.SuddenDeath.TotalMinutes}:{tourney.SuddenDeath.Seconds:D2} (first {tourney.SuddenDeathRounds} rounds)" :
|
|
$"Sudden Death: {(int)tourney.SuddenDeath.TotalMinutes}:{tourney.SuddenDeath.Seconds:D2} (all rounds)";
|
|
}
|
|
else
|
|
{
|
|
sdText = "Sudden Death: Off";
|
|
}
|
|
|
|
AddHtml(35, y, 240, 20, sdText);
|
|
y += 20;
|
|
|
|
y += 8;
|
|
|
|
AddHtml(35, y, 190, 20, $"Ruleset: {basedef.Title}");
|
|
y += 20;
|
|
|
|
for (var i = 0; i < ruleset.Flavors.Count; ++i, y += 18)
|
|
{
|
|
AddHtml(35, y, 190, 20, $" + {ruleset.Flavors[i].Title}");
|
|
}
|
|
|
|
y += 4;
|
|
|
|
if (changes > 0)
|
|
{
|
|
AddHtml(35, y, 190, 20, "Modifications:");
|
|
y += 20;
|
|
|
|
for (var i = 0; i < opts.Length; ++i)
|
|
{
|
|
if (defs[i] != opts[i])
|
|
{
|
|
var name = ruleset.Layout.FindByIndex(i);
|
|
|
|
if (name != null) // sanity
|
|
{
|
|
AddImage(35, y, opts[i] ? 0xD3 : 0xD2);
|
|
AddHtml(60, y, 165, 22, name);
|
|
}
|
|
|
|
y += 22;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddHtml(35, y, 190, 20, "Modifications: None");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Participant_List:
|
|
{
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 300, 9380);
|
|
|
|
var pList = m_List?.SafeConvertList<object, TourneyParticipant>()
|
|
?? new List<TourneyParticipant>(tourney.Participants);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 0));
|
|
AddHtml(25, 35, 250, 20, Html.Center($"{pList.Count} Participant{(pList.Count == 1 ? "" : "s")}"));
|
|
|
|
StartPage(out var index, out var count, out var y, 12);
|
|
|
|
for (var i = 0; i < count; ++i, y += 18)
|
|
{
|
|
var part = pList[index + i];
|
|
var name = part.NameList;
|
|
|
|
if (m_Tournament.TourneyType != TourneyType.Standard && part.Players.Count == 1)
|
|
{
|
|
if (part.Players[0] is PlayerMobile pm && pm.DuelPlayer != null)
|
|
{
|
|
name = name.Color(pm.DuelPlayer.Eliminated ? 0x663333 : 0x336666);
|
|
}
|
|
}
|
|
|
|
AddRightArrow(25, y, ToButtonID(2, index + i), name);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Participant_Info:
|
|
{
|
|
if (obj is not TourneyParticipant part)
|
|
{
|
|
break;
|
|
}
|
|
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 60 + 18 + 20 + part.Players.Count * 18 + 20 + 20 + 160, 9380);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 1));
|
|
AddHtml(25, 35, 250, 20, "Participants".Center());
|
|
|
|
var y = 53;
|
|
|
|
AddHtml(25, y, 200, 20, part.Players.Count == 1 ? "Players" : "Team");
|
|
y += 20;
|
|
|
|
for (var i = 0; i < part.Players.Count; ++i)
|
|
{
|
|
var mob = part.Players[i];
|
|
var name = mob.Name;
|
|
|
|
if (m_Tournament.TourneyType != TourneyType.Standard)
|
|
{
|
|
if (mob is PlayerMobile pm && pm.DuelPlayer != null)
|
|
{
|
|
name = name.Color(pm.DuelPlayer.Eliminated ? 0x663333 : 0x336666);
|
|
}
|
|
}
|
|
|
|
AddRightArrow(35, y, ToButtonID(4, i), name);
|
|
y += 18;
|
|
}
|
|
|
|
AddHtml(
|
|
25,
|
|
y,
|
|
200,
|
|
20,
|
|
$"Free Advances: {(part.FreeAdvances == 0 ? "None" : part.FreeAdvances.ToString())}"
|
|
);
|
|
y += 20;
|
|
|
|
AddHtml(25, y, 200, 20, "Log:");
|
|
y += 20;
|
|
|
|
using var sb = ValueStringBuilder.Create();
|
|
|
|
for (var i = 0; i < part.Log.Count; ++i)
|
|
{
|
|
if (sb.Length > 0)
|
|
{
|
|
sb.Append("<br>");
|
|
}
|
|
|
|
sb.Append(part.Log[i]);
|
|
}
|
|
|
|
if (sb.Length == 0)
|
|
{
|
|
sb.Append("Nothing logged yet.");
|
|
}
|
|
|
|
AddHtml(25, y, 250, 150, sb.AsSpan().Color(BlackColor32), false, true);
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Player_Info:
|
|
{
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 300, 9380);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 3));
|
|
AddHtml(25, 35, 250, 20, "Participants".Center());
|
|
|
|
if (obj is not Mobile mob)
|
|
{
|
|
break;
|
|
}
|
|
|
|
var ladder = Ladder.Instance;
|
|
var entry = ladder?.Find(mob);
|
|
|
|
AddHtml(25, 53, 250, 20, $"Name: {mob.Name}");
|
|
AddHtml(
|
|
25,
|
|
73,
|
|
250,
|
|
20,
|
|
$"Guild: {(mob.Guild == null ? "None" : $"{mob.Guild.Name} [{mob.Guild.Abbreviation}]")}"
|
|
);
|
|
AddHtml(25, 93, 250, 20, $"Rank: {(entry == null ? "N/A" : LadderGump.Rank(entry.Index + 1))}");
|
|
AddHtml(25, 113, 250, 20, $"Level: {(entry == null ? 0 : Ladder.GetLevel(entry.Experience))}");
|
|
AddHtml(25, 133, 250, 20, $"Wins: {entry?.Wins ?? 0:N0}");
|
|
AddHtml(25, 153, 250, 20, $"Losses: {entry?.Losses ?? 0:N0}");
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Round_List:
|
|
{
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 300, 9380);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 0));
|
|
AddHtml(25, 35, 250, 20, "Rounds".Center());
|
|
|
|
StartPage(out var index, out var count, out var y, 12);
|
|
|
|
for (var i = 0; i < count; ++i, y += 18)
|
|
{
|
|
AddRightArrow(25, y, ToButtonID(3, index + i), $"Round #{index + i + 1}");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Round_Info:
|
|
{
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 300, 9380);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 2));
|
|
AddHtml(25, 35, 250, 20, "Rounds".Center());
|
|
|
|
if (m_Object is not PyramidLevel level)
|
|
{
|
|
break;
|
|
}
|
|
|
|
var matchesList = m_List != null
|
|
? m_List.SafeConvertList<object, TourneyMatch>()
|
|
: new List<TourneyMatch>(level.Matches);
|
|
|
|
AddRightArrow(
|
|
25,
|
|
53,
|
|
ToButtonID(5, 0),
|
|
$"Free Advance: {(level.FreeAdvance == null ? "None" : level.FreeAdvance.NameList)}"
|
|
);
|
|
|
|
AddHtml(25, 73, 200, 20, $"{matchesList.Count} Match{(matchesList.Count == 1 ? "" : "es")}");
|
|
|
|
StartPage(out var index, out var count, out var y, 10);
|
|
|
|
for (var i = 0; i < count; ++i, y += 18)
|
|
{
|
|
var match = matchesList[index + i];
|
|
|
|
var color = -1;
|
|
|
|
if (match.InProgress)
|
|
{
|
|
color = 0x336666;
|
|
}
|
|
else if (match.Context != null && match.Winner == null)
|
|
{
|
|
color = 0x666666;
|
|
}
|
|
|
|
using var sb = ValueStringBuilder.Create(512);
|
|
|
|
if (m_Tournament.TourneyType == TourneyType.Standard)
|
|
{
|
|
for (var j = 0; j < match.Participants.Count; ++j)
|
|
{
|
|
if (sb.Length > 0)
|
|
{
|
|
sb.Append(" vs ");
|
|
}
|
|
|
|
var part = match.Participants[j];
|
|
var txt = part.NameList;
|
|
|
|
if (color == -1 && match.Context != null && match.Winner == part)
|
|
{
|
|
txt = txt.Color(0x336633);
|
|
}
|
|
else if (color == -1 && match.Context != null)
|
|
{
|
|
txt = txt.Color(0x663333);
|
|
}
|
|
|
|
sb.Append(txt);
|
|
}
|
|
}
|
|
else if (m_Tournament.EventController != null ||
|
|
m_Tournament.TourneyType is TourneyType.RandomTeam or TourneyType.RedVsBlue or TourneyType.Faction)
|
|
{
|
|
for (var j = 0; j < match.Participants.Count; ++j)
|
|
{
|
|
if (sb.Length > 0)
|
|
{
|
|
sb.Append(" vs ");
|
|
}
|
|
|
|
var part = match.Participants[j];
|
|
string txt;
|
|
|
|
if (m_Tournament.EventController != null)
|
|
{
|
|
txt = $"Team {m_Tournament.EventController.GetTeamName(j)} ({part.Players.Count})";
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.RandomTeam)
|
|
{
|
|
txt = $"Team {j + 1} ({part.Players.Count})";
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.Faction)
|
|
{
|
|
if (m_Tournament.ParticipantsPerMatch == 4)
|
|
{
|
|
var name = j switch
|
|
{
|
|
0 => "Minax",
|
|
1 => "Council of Mages",
|
|
2 => "True Britannians",
|
|
3 => "Shadowlords",
|
|
_ => "(null)"
|
|
};
|
|
|
|
txt = $"{name} ({part.Players.Count})";
|
|
}
|
|
else if (m_Tournament.ParticipantsPerMatch == 2)
|
|
{
|
|
txt = $"{(j == 0 ? "Evil" : "Hero")} Team ({part.Players.Count})";
|
|
}
|
|
else
|
|
{
|
|
txt = $"Team {j + 1} ({part.Players.Count})";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
txt = $"Team {(j == 0 ? "Red" : "Blue")} ({part.Players.Count})";
|
|
}
|
|
|
|
if (color == -1 && match.Context != null && match.Winner == part)
|
|
{
|
|
txt = txt.Color(0x336633);
|
|
}
|
|
else if (color == -1 && match.Context != null)
|
|
{
|
|
txt = txt.Color(0x663333);
|
|
}
|
|
|
|
sb.Append(txt);
|
|
}
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.FreeForAll)
|
|
{
|
|
sb.Append("Free For All");
|
|
}
|
|
|
|
var str = sb.ToString();
|
|
|
|
if (color >= 0)
|
|
{
|
|
str = str.Color(color);
|
|
}
|
|
|
|
AddRightArrow(25, y, ToButtonID(5, index + i + 1), str);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case TourneyBracketGumpType.Match_Info:
|
|
{
|
|
if (obj is not TourneyMatch match)
|
|
{
|
|
break;
|
|
}
|
|
|
|
var ct = m_Tournament.TourneyType == TourneyType.FreeForAll ? 2 : match.Participants.Count;
|
|
|
|
AddPage(0);
|
|
AddBackground(0, 0, 300, 60 + 18 + 20 + 20 + 20 + ct * 18 + 6, 9380);
|
|
|
|
AddLeftArrow(25, 11, ToButtonID(0, 5));
|
|
AddHtml(25, 35, 250, 20, "Rounds".Center());
|
|
|
|
AddHtml(25, 53, 250, 20, $"Winner: {(match.Winner == null ? "N/A" : match.Winner.NameList)}");
|
|
AddHtml(
|
|
25,
|
|
73,
|
|
250,
|
|
20,
|
|
$"State: {(match.InProgress ? "In progress" : match.Context != null ? "Complete" : "Waiting")}"
|
|
);
|
|
AddHtml(25, 93, 250, 20, "Participants:");
|
|
|
|
if (m_Tournament.TourneyType == TourneyType.Standard)
|
|
{
|
|
for (var i = 0; i < match.Participants.Count; ++i)
|
|
{
|
|
var part = match.Participants[i];
|
|
|
|
AddRightArrow(25, 113 + i * 18, ToButtonID(6, i), part.NameList);
|
|
}
|
|
}
|
|
else if (m_Tournament.EventController != null ||
|
|
m_Tournament.TourneyType is TourneyType.RandomTeam or TourneyType.RedVsBlue or TourneyType.Faction)
|
|
{
|
|
for (var i = 0; i < match.Participants.Count; ++i)
|
|
{
|
|
var part = match.Participants[i];
|
|
|
|
if (m_Tournament.EventController != null)
|
|
{
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"Team {m_Tournament.EventController.GetTeamName(i)} ({part.Players.Count})"
|
|
);
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.RandomTeam)
|
|
{
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"Team {i + 1} ({part.Players.Count})"
|
|
);
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.Faction)
|
|
{
|
|
if (m_Tournament.ParticipantsPerMatch == 4)
|
|
{
|
|
var name = i switch
|
|
{
|
|
0 => "Minax",
|
|
1 => "Council of Mages",
|
|
2 => "True Britannians",
|
|
3 => "Shadowlords",
|
|
_ => "(null)"
|
|
};
|
|
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"{name} ({part.Players.Count})"
|
|
);
|
|
}
|
|
else if (m_Tournament.ParticipantsPerMatch == 2)
|
|
{
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"{(i == 0 ? "Evil" : "Hero")} Team ({part.Players.Count})"
|
|
);
|
|
}
|
|
else
|
|
{
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"Team {i + 1} ({part.Players.Count})"
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddRightArrow(
|
|
25,
|
|
113 + i * 18,
|
|
ToButtonID(6, i),
|
|
$"Team {(i == 0 ? "Red" : "Blue")} ({part.Players.Count})"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else if (m_Tournament.TourneyType == TourneyType.FreeForAll)
|
|
{
|
|
AddHtml(25, 113, 250, 20, "Free For All");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddBorderedText(int x, int y, int width, int height, string text, int color, int borderColor)
|
|
{
|
|
AddColoredText(x - 1, y - 1, width, height, text, borderColor);
|
|
AddColoredText(x - 1, y + 1, width, height, text, borderColor);
|
|
AddColoredText(x + 1, y - 1, width, height, text, borderColor);
|
|
AddColoredText(x + 1, y + 1, width, height, text, borderColor);
|
|
AddColoredText(x, y, width, height, text, color);
|
|
}
|
|
|
|
private void AddColoredText(int x, int y, int width, int height, string text, int color)
|
|
{
|
|
if (color == 0)
|
|
{
|
|
AddHtml(x, y, width, height, text);
|
|
}
|
|
else
|
|
{
|
|
AddHtml(x, y, width, height, text.Color(color));
|
|
}
|
|
}
|
|
|
|
public void AddRightArrow(int x, int y, int bid, string text)
|
|
{
|
|
AddButton(x, y, 0x15E1, 0x15E5, bid);
|
|
|
|
if (text != null)
|
|
{
|
|
AddHtml(x + 20, y - 1, 230, 20, text);
|
|
}
|
|
}
|
|
|
|
public void AddRightArrow(int x, int y, int bid)
|
|
{
|
|
AddRightArrow(x, y, bid, null);
|
|
}
|
|
|
|
public void AddLeftArrow(int x, int y, int bid, string text)
|
|
{
|
|
AddButton(x, y, 0x15E3, 0x15E7, bid);
|
|
|
|
if (text != null)
|
|
{
|
|
AddHtml(x + 20, y - 1, 230, 20, text);
|
|
}
|
|
}
|
|
|
|
public void AddLeftArrow(int x, int y, int bid)
|
|
{
|
|
AddLeftArrow(x, y, bid, null);
|
|
}
|
|
|
|
public int ToButtonID(int type, int index) => 1 + index * 7 + type;
|
|
|
|
public bool FromButtonID(int bid, out int type, out int index)
|
|
{
|
|
type = (bid - 1) % 7;
|
|
index = (bid - 1) / 7;
|
|
return bid >= 1;
|
|
}
|
|
|
|
public void StartPage(out int index, out int count, out int y, int perPage)
|
|
{
|
|
m_PerPage = perPage;
|
|
|
|
index = Math.Max(m_Page * perPage, 0);
|
|
count = Math.Clamp(m_List.Count - index, 0, perPage);
|
|
|
|
y = 53 + (12 - perPage) * 18;
|
|
|
|
if (m_Page > 0)
|
|
{
|
|
AddLeftArrow(242, 35, ToButtonID(1, 0));
|
|
}
|
|
|
|
if ((m_Page + 1) * perPage < m_List.Count)
|
|
{
|
|
AddRightArrow(260, 35, ToButtonID(1, 1));
|
|
}
|
|
}
|
|
|
|
public override void OnResponse(NetState sender, in RelayInfo info)
|
|
{
|
|
if (!FromButtonID(info.ButtonID, out var type, out var index))
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
{
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(m_From, m_Tournament, TourneyBracketGumpType.Index)
|
|
);
|
|
break;
|
|
case 1:
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Participant_List
|
|
)
|
|
);
|
|
break;
|
|
case 2:
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(m_From, m_Tournament, TourneyBracketGumpType.Round_List)
|
|
);
|
|
break;
|
|
case 4:
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(m_From, m_Tournament, TourneyBracketGumpType.Rules_Info)
|
|
);
|
|
break;
|
|
case 3:
|
|
{
|
|
var mob = m_Object as Mobile;
|
|
|
|
for (var i = 0; i < m_Tournament.Participants.Count; ++i)
|
|
{
|
|
var part = m_Tournament.Participants[i];
|
|
|
|
if (part.Players.Contains(mob))
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Participant_Info,
|
|
null,
|
|
0,
|
|
part
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (m_Object is not TourneyMatch match)
|
|
{
|
|
break;
|
|
}
|
|
|
|
for (var i = 0; i < m_Tournament.Pyramid.Levels.Count; ++i)
|
|
{
|
|
var level = m_Tournament.Pyramid.Levels[i];
|
|
|
|
if (level.Matches.Contains(match))
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Round_Info,
|
|
null,
|
|
0,
|
|
level
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
{
|
|
if (m_List != null && m_Page > 0)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
m_Type,
|
|
m_List,
|
|
m_Page - 1,
|
|
m_Object
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if (m_List != null && (m_Page + 1) * m_PerPage < m_List.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
m_Type,
|
|
m_List,
|
|
m_Page + 1,
|
|
m_Object
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
if (m_Type != TourneyBracketGumpType.Participant_List)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (index >= 0 && index < m_List.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Participant_Info,
|
|
null,
|
|
0,
|
|
m_List[index]
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
if (m_Type != TourneyBracketGumpType.Round_List)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (index >= 0 && index < m_List.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Round_Info,
|
|
null,
|
|
0,
|
|
m_List[index]
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
if (m_Type != TourneyBracketGumpType.Participant_Info)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (m_Object is TourneyParticipant part && index >= 0 && index < part.Players.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Player_Info,
|
|
null,
|
|
0,
|
|
part.Players[index]
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (m_Type != TourneyBracketGumpType.Round_Info)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (m_Object is not PyramidLevel level)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (index == 0)
|
|
{
|
|
if (level.FreeAdvance != null)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Participant_Info,
|
|
null,
|
|
0,
|
|
level.FreeAdvance
|
|
)
|
|
);
|
|
}
|
|
else
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(m_From, m_Tournament, m_Type, m_List, m_Page, m_Object)
|
|
);
|
|
}
|
|
}
|
|
else if (index >= 1 && index <= level.Matches.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Match_Info,
|
|
null,
|
|
0,
|
|
level.Matches[index - 1]
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
if (m_Type != TourneyBracketGumpType.Match_Info)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (m_Object is TourneyMatch match && index >= 0 && index < match.Participants.Count)
|
|
{
|
|
m_From.SendGump(
|
|
new TournamentBracketGump(
|
|
m_From,
|
|
m_Tournament,
|
|
TourneyBracketGumpType.Participant_Info,
|
|
null,
|
|
0,
|
|
match.Participants[index]
|
|
)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|