← All proposalsWork blog
Oil painting of five adventurers signing a parchment charter at a candlelit tavern table, their painted company banner on the wall behind them

The Company You Keep

A deep dive into party and grouping in Shroud of the Avatar, what Ultima Online and twenty-five years of games since can teach it, and thirty-four concrete proposals.

SotA's party system is better built than its reputation: a dedicated social server, a twelve-member roster with leader roles, three loot rules with a roll threshold and a self-service opt-out, a party XP bonus, party chat, instance matchmaking that follows the leader, and a Looking For More window that finished its move to UI Toolkit this summer. And yet a party here still has no name, no memory past a twenty minute database timeout, no dot on the compass, no ready check, and no answer to the question a small population asks every night: who else is out there, and how do we find each other? This document surveys what the genre and its fiction learned about adventuring parties, measures our system against it, and proposes thirty-four improvements, each grounded in the actual classes that would carry them.

0 · Executive summary 1 · The party today 2 · Lessons: Ultima Online to modern 3 · The thirty-four proposals    Tier 1 · Quick wins (S1–S11)    Tier 2 · Core upgrades (S12–S23)    Tier 3 · Server-backed (S24–S34)    Considered and rejected 4 · The Company Window 5 · Sequencing 6 · Appendix
Section 0

Executive summary

Ultima Online ran for thirty-one months without a party system at all, and it worked, because in a use-based, classless sandbox the rewards were already individual. When Publish 5 finally retrofitted parties in April 2000 it shipped a small, exact list: a roster, a chat channel, consent flags for looting, shared fame, and dots on the map. The genre then spent twenty-five years elaborating on that list, and the elaborations sort cleanly by population. Queues, role gates, and level penalties assume a deep pool of strangers; boards, mentor pairs, NPC companions, and named companies work with whoever is actually online. Shroud of the Avatar sits today almost exactly where UO sat in early 2000: the wire protocol is complete, the loot rules exist, a party finder is live and freshly rebuilt in UI Toolkit, and the classless flat XP split already lets a ten-year veteran and a week-old newcomer hunt side by side with no penalty. What is missing is everything that makes a party feel like a company rather than a shared damage ledger.

The gaps cluster in three places, and they are exactly the three promises on this page's tile:

  1. Finding each other. The Looking For More system exists and is orphaned: nothing routes a player to it, listings have no activity tags, no time, no tavern presence, and there is no open-party or call-for-help path across the game's three multiplayer modes. The genre's answer at this population is boards and beacons, never queues.
  2. Fairness you can see. XP splits evenly with a party bonus, but the twenty meter share radius is invisible and players discover it by silently earning nothing. Loot has three rules where the genre settled on five, and no receipt anywhere says what was shared and how.
  3. Being a party. No name, no banner, no history; state dies on a twenty minute timeout. No target marks, ready checks, pins, or compass dots. Beyond standing in the same scene, there is almost nothing a party does as a party.

Thirty-four proposals follow. Eleven are small client-only changes, several of them plain bug fixes. Twelve are larger client work, all riding one existing extension point (the party member property bag) with no new network operations. Eleven need real server work, and each of those carries its exact cost in the open: which request group it rides, whether it touches the database, and what the migrations ledger owes.

#ProposalTierSizeServerOne-line pitch
S1Party plumbing repair1Snonepets heal the party again; three dead ends closed
S2The XP link light1Snonesee who is inside the share range, live
S3The share receipt1Snoneone chat line shows the kill's XP math
S4Ready check and countdown1Snone/readycheck and /pull 5, twenty years overdue
S5Target marks1Snoneskull, moon, cross over enemy heads, party-wide
S6Trusted-party toggles1Snonestop confirming your own party's summons
S7Auto-accept from friends1Snoneinvites from friends and guildmates skip the dialog
S8Party row quick actions1Snoneright-click a row for whisper, promote, teleport, kick
S9Link-dead countdown1Snonethe twenty minute grace period, made visible
S10Surface the finder1Snone/lfm, a live badge, a login nudge for the window we already built
S11The party toast1Snonea ritual flourish the whole party answers
S12Cross-scene vitals2Mnonehealth bars that survive scene lines
S13In-scene party markers2Mnonecompass dots and edge arrows for members
S14Overworld markers rebuilt2Mnonethe last NGUI party remnant retired
S15Pins and pings2Mnonedrop a numbered pin; everyone sees it
S16The Adventurer's Board2Lnonethe party finder becomes a real board with tags and times
S17Open party2Mnonewalk-ups welcome; join the party by the waterfall in one click
S18The signal arrow2Lnonefire a flare mid-fight; help converges on you
S19Named parties2Mnonethe party gets a name and wears it everywhere
S20Round-robin loot2Lnonecorpses rotate through the roster, fair and silent
S21The expedition ledger2Mnonethe session's shares and rolls, on paper at disband
S22Mentor's mark2Mnonesurface the mentoring the game already does in secret
S23The tavern muster2Lcontenta placeable board deco that opens the Board in player taverns
S24Anyone-may-invite3Sperm checka party setting ends the wait-for-the-leader tax
S25A wider share circle3Stweak defaultthe 20 m XP radius grows to 40 m
S26Need before greed3Mop paramsthe loot roll grows Need and Greed buttons
S27The persistent board3Lnew collectionposts that outlive the party: Saturday 8pm, sign here
S28Raise a glass3Mop + statcommend one companion when the party ends
S29The mentor's kicker3MXP-loop termveterans earn a bonus for hunting with true newcomers
S30Announce the company3Spayload fieldthe boss announcement carries the party's name
S31The Company charter3XLfull stacka named fellowship that survives logout, with a chronicle
S32The company banner3Lrides S31the sigil made physical: field, housing, tavern wall
S33The muster3XLencounter logiccontrol points that answer party size with escalation
S34Hired blades3XLepic-gatedbot companions fill the empty slots for a cut of the gold
Section 1

The party today

Credit first, because there is a lot to credit. The party stack finished its UI Toolkit migration this summer: the HUD member column, the Social window's Party tab, the Looking For More window, the invitation dialog, the players-in-scene list, and the teleport picker are all rebuilt, with the party leader's star on nameplates and four EditMode test suites pinning the tricky logic. The loot roll opt-out that Tirrag asked for on the forum shipped in July, an instance-relabelling XP exploit was closed on both halves, and the Summon Party scroll, broken for years, casts again. The system underneath is a real one: parties live on their own social server with a twelve-member cap, leader roles, a sixty second invite timeout, automatic leader succession by seniority, and a matchmaking loop that walks the whole party into the leader's instance.

Here is what a player actually sees, and where it stops short. Four surfaces, none of them aware of the others:

The HUD column (rebuilt, honest, minimal)
Tirrag
Mondravis
Cora Cuz'avich
Soltown
The Social window's Party tab (settings, invites)
Party
New PartyJoin Party
Invite a player by nameSend
Loot ruleRollThreshold500
[ ] Sit out loot rolls
The Looking For More window (built, orphaned)
Looking for More
PartyPlayers
Tirrag's party3Join
Reachable only if you already know it exists
Everything else
Compass:no party dots
Overworld map:one NGUI label per member
Options:party settings on three different tabs
Party name:none. Memory: 20 minutes.

The machinery every proposal plugs into

Party state lives on the social server, one authoritative object per party on its own fiber, reached through the group server's request router. The game server never holds a roster: when a kill pays out, the master client sends the actor list and the server splits evenly, applies the party bonus terms, and fans out. The client's PartyManager owns everything the player sees, and per-member data travels in exactly one extension point: the member property bag, four keys today, published by each member and rebroadcast to the rest of the party unread by the server. Almost every proposal below is either a new bag key, a new message on the existing party chat control channel, or a new consumer of data already arriving.

flowchart LR
  A["PartyManager\n(client)"] --> B["GroupClientPeer\nrequest router"]
  B --> C["Party object\nsocial server, own fiber"]
  C --> D[("PartyMember +\nPartyStorage\nMongo, TTL 20 min")]
  C --> E["IPartyEvent fan-out\nto every member"]
  subgraph XP["the XP lane (separate server)"]
    F["AwardXPForDead\nmaster client"] --> G["ChangeCharacterExperience\nForCombat + actor list"]
    G --> H["GameImpl split loop\neven split + bonus terms"]
  end
  style C stroke:#c9a55a,stroke-width:2px
  style D stroke:#c9a55a,stroke-width:2px
The two hard constraints. First: the game server holds no party roster and no player positions, so nothing server-side can gate on formation or geometry; party membership arrives as a client-sent actor list, and the server's anti-exploit checks are deliberately structural, not spatial. Second: parties are twenty minute TTL database records. Anything that should outlive a login session needs new durable storage, and exactly one proposal below pays that full price on purpose.
Section 2

Lessons: Ultima Online to modern

UO launched in September 1997 with no party system at all. Grouping meant standing near friends and trusting them, and the game's early flagging rules actively punished cooperation: healing a criminal made you a criminal, and helping the wrong person got you cut down by town guards. Guilds arrived in 1998 and carried group play for two years. Then Publish 5, in April 2000, retrofitted the entire party stack in one publish: a ten-member roster with leader-only adds, party chat with per-member tells, status bars built for fast support play, shared fame and karma at full value for everyone, dots on the radar map, and the most SotA-shaped idea in the whole survey, a per-player consent flag reading simply party can loot me. No XP math, no roles, no matchmaking. That minimal list carried the game for a decade.

UO's loot rights are the best-aged idea here: corpse access accrues from damage points, indirect contribution counts (a tamer's pet credits the tamer), and anyone within thirty percent of the top contributor loots. It took until Publish 74, in 2012, for healers and tanks to count equally, twelve years to learn that support play is contribution. And in 2024, UO's New Legacy season turned group identity itself into a reward, reserving the largest houses for guilds. Twenty-seven years on, the ancestor is still arguing that the group is the endgame.

Oil painting of a small company on a stone causeway at dusk, an armored veteran walking beside a young mage, a ranger ahead with a lantern
The whole argument in one image: the veteran slows to the newcomer's pace, and the game should pay him for it. SotA's classless flat split already lets these two hunt together; nothing yet makes it an institution.
1997
UO ships partyless
31 months of purely social grouping in a classless sandbox. It worked.
2000
UO Publish 5
The whole retrofit at once: roster, chat, consent loot flags, map dots.
2001
EQ group math
+2% to +20% group XP bonus; a 6-man divides by 5. The sixth player is a strict gain.
2004
CoH Sidekick
Level gaps stop being a reason not to play together. The flagship low-pop pattern.
2006
WoW 1.11
Ready check and target markers, both canon within a year, both cheap.
2009
Dungeon Finder
The queue era opens. Convenience up, community measurably down.
2013
FFXIV Party Finder
An authored listing board that works at any population. The other road.
2019
Trust + Party Sync
NPC companions and story sync land the same year. Nobody blocks on strangers.
2022–24
The walk-back
WotLK Classic ships with no queue, on purpose. Follower Dungeons let NPCs fill. UO New Legacy makes the group the prize.

What each game contributes

EverQuest: group XP as a strict mathematical win, and the social machinery of camps, pullers, and camp checks that a single server's reputation enforced without code. Also the cautionary trinity: three of fourteen classes mandatory for everything. City of Heroes: sidekicking, then Super Sidekicking in 2009, the whole team auto-set to the mission owner's level. In a shrinking population this is the difference between forty people online and forty people you can group with; SotA's classless design gets most of this for free and should say so out loud. WoW: the full arc, from LFG channel to Dungeon Finder to Raid Finder, then the slow regret, and the two features from 2006 nobody ever regretted: ready checks and raid marks. Its 2014 premade Group Finder quietly re-added the manual board it had replaced. FFXIV: Party Finder listings, post-duty commendations feeding a titled mentor rank, and Trusts, story NPCs as party members, the proof that NPC fill can be a narrative reward instead of a crutch. Guild Wars 2: no kill stealing, per-player nodes, everyone-tags credit, and the mentor tag with zero mechanics that people still wear. OSRS: when you cannot afford matchmaking, ship a board and a channel and let the community do the rest. Monster Hunter World: the SOS flare, converting solo players to co-op at the exact moment difficulty appears. Deep Rock Galactic and Sea of Thieves: rituals as retention, a salute, a shanty, a round of grog; the crew is the content. Baldur's Gate 3 and the classic CRPGs: the camp as social anchor, and the tavern, from Gilgamesh's in 1981 onward, as the named place where parties are formed. SotA has player-run taverns doing nothing mechanical, which reads less like a gap and more like an invitation.

And the fiction is unanimous. The Fellowship was chosen, named, and commissioned before it walked a mile. Kurosawa's samurai are recruited one by one for distinct competences, and Heihachi paints the company's banner: six circles and a triangle, flying over the village. Critical Role's Vox Machina named itself on stream, first draft rejected, and built an empire on the name. Roughly two thirds of tabletop campaigns begin in a tavern. What fiction says a party is, and what almost no MMO has ever shipped, is a named, persistent, heraldic thing with a founding story: a name, a motto, a sigil, a banner, a chronicle of deeds, and a table where it drinks. That is Tier 3 of this document.

Anti-patterns this page will not propose. Auto-matchmaking queues (need population this game does not have, and carry a documented social cost; the PvP page's rejection of queues is standing law here). Role queues and trinity gates (incompatible with classless skills). Level-gap XP penalties (would kill exactly the veteran-newcomer duos this game needs; SotA's flat split is already the right answer). Master-loot councils (the genre spent fourteen years unwinding them). Content behind a fixed party-size door (encounters scale, never gate).

Capability matrix

CapabilityUOEQWoWFFXIVGW2CoHSotA todaySotA proposed
Finding a group: boards and listings◔ orphaned● S10/S16/S27
Auto-matchmaking queue○ by design
Group XP bonus and visible fair split◔*◔ invisible● S2/S3
Playing across level gaps◔*◔ free, unsung● S22/S29
NPC fill of empty slots◔ S34 gated
Loot rule options◔ three rules● S20/S26
Support play counts as contribution● Pub 74◔ in party◔ cited†
Consent flags: loot me, opt-outs◔ one flag● S6/S7
Party identity: name, banner, history● S19/S31/S32
Target marks and pings● S5/S15
Ready check and countdown● S4
Cross-scene and map awareness● 2000◔ labels● S12–S15
Summon or rally the party◔ scroll● S6/S18
Mentor and veteran pairing◔ hidden● S22/S28/S29
Open party and join-in-progress◔ S17/S18

● native · ◔ partial · ○ absent. *UO has no XP: it shared fame and karma at full value, and its use-based skills sidestep the level-gap problem entirely, the same structural position SotA holds. †Within a party, SotA's even split already pays healers and tanks; credit for helping strangers is the life-magic page's open question (its S20), cited here rather than re-proposed. The queue row stays empty by design: the PvP page's ruling stands, below a few hundred concurrent players a clock beats a queue. True open-party exemplars, Warhammer Online 2008 and Monster Hunter's SOS flare, are cited on their cards.

Section 3

The thirty-four proposals

Numbering runs S1 to S34 in build-order tiers. Tier 1 is client-only and small; Tier 2 is client work of real size, all of it riding the existing member property bag and party chat channel with no new network operations; Tier 3 needs the server, and every card there states its exact cost. Sample names in the mockups belong to real players whose forum requests shaped this page.

Tier 1 · Quick wins, client-only

S1 · Party plumbing repair

Tier 1Size SServer: none

Four latent defects fixed in one sweep. The big one: your pet does not heal or buff your party, and never has, because of an inverted null check in the pet AI's target search; the list of party members being present is exactly what makes the routine give up. The others: the build-mismatch check silently abandons the whole party scan when one member is between rooms, a loot roll claim that fails does nothing at all, and one finder response path would crash if it ever fired. Invisible until fixed; afterward the game just feels like it works.

Seen in: every companion-AI game since Guild Wars henchmen (2005), where the pet helping the group is the baseline.

Implementation notes

The pet fix is the guard clause in BAFindHealTarget.AddPartyMembers and its twin in BAFindBuffTarget: the partyMembers != null term inverts the intended null guard, so the routine returns the moment a party list exists. The mismatch check needs continue where it has return in PartyManager.CheckForBuildNumberMismatch. The claim failure in LootRollItem.ClaimLootRoll carries a to-do comment and does nothing; give it the standard retry-or-report path. The dead finder response (StopLookingForMorePartyPropertiesResponse) throws by design of neglect; S10 puts the whole path back to work.

Behavior note: the pet heal fix changes live pet behavior. Verify against the taming page's in-flight guard-ally card so the two features agree on target priority.

client Sserver noneperf nonetests pet target-list EditMode cases

S2 · The XP link light

Tier 1Size SServer: none

A small chain-link mark on each party row that lights while that member is inside XP share range of you and dims when they wander past it. The range gate is real: a member more than twenty meters from the kill earns nothing, and nothing in the game says so. People lose XP for hours and never learn why. Fair sharing you cannot see is not fair sharing; it is a rumor.

Seen in: EverQuest's share-range culture made explicit; every modern raid frame's range fade.

Implementation notes

The distance set already exists and is already cheap: PartyManager.GetOtherPartyMembersInCurrentSceneWithinDistance runs against TweakValues.Player_ExpBonusMaxRangeSquared using reusable scratch lists, and combat calls it constantly. The row mark on PartyMemberUI piggybacks the cached nearby set; never add a new per-frame iteration. Extend PartyHudModelTests.

client Sserver noneperf reuses cached settests PartyHudModelTests

S3 · The share receipt

Tier 1Size SServer: none

When the party kills something notable, one chat line shows the math: the XP pot, the party bonus, your share, and how many members were in range to collect. Gold already prints a share line when it splits; experience, the thing people actually argue about, prints nothing. The receipt turns the split from folklore into arithmetic.

Seen in: EverQuest's group XP text (1999), Guild Wars 2 participation ticks, Monster Hunter's quest result screens.

Chat
[Party]Troll of Blood Bay defeated.
[Party]Party kill: 1,200 XP pot with a 30 percent party bonus. Your share: 312. In range: 4 of 5.
[Party]You received your share of 85 gold from the 425 gold that you picked up.
Implementation notes

The pot math already runs on the scene's master client (PlayerController.GetTotalXPWithPartyBonus inside AwardXPForDead). Broadcast the breakdown over the party chat control channel exactly like the existing summon-countdown key: a new one-character key beside PartyPropertiesKey.Chat and .Joining, sent from the master client, rendered as a system line. When the master client is not a party member (open instance), no one computes the breakdown: degrade to silence, never guess. Throttle to bosses and to one line per N seconds so farming nights stay readable; the threshold rides the roll-threshold pattern.

client Sserver noneperf one chat line per notable killtests receipt formatter unit tests

S4 · Ready check and pull countdown

Tier 1Size SServer: none

/readycheck pops a yes-or-no on every member's screen and reports the tally back; /pull 5 counts down in party chat. These are the two cheapest coordination verbs in the genre, canon since the summer of 2006, and SotA has neither. Every boss attempt currently starts with someone typing "ready?" and hoping.

Seen in: WoW patch 1.11.0 (June 2006); FFXIV's built-in countdown; GW2 squad ready checks.

Ready Check
Tirrag asks: is everyone ready?
ReadyNot yet
[Party]Ready: 4 of 5. Waiting on Rinaldi.
Implementation notes

Both verbs ride the party chat control channel (the PartyPropertiesKey pattern): a check id plus per-member answers, a countdown start plus tick rendering. Slash entries go in the ChatUI.ProcessSlashCommand switch beside /invite. The dialog is a SotAUitkWindow like the invitation dialog; answers render as chips on the party rows (see the S12 HUD delta). Non-member messages are already dropped, so spoofing is bounded to the party.

client Sserver noneperf nonetests check-state model tests

S5 · Target marks

Tier 1Size SServer: none

Anyone in the party stamps a skull, moon, or cross over an enemy's head, and everyone sees it. "Kill skull first, leave moon for the tamer" replaces a paragraph of typing. Pound for pound the highest-value coordination feature in MMO history, and it is a client-side broadcast away.

Seen in: WoW 1.11.0 raid markers (June 2006); GW2 squad markers (2015).

Implementation notes

Mark assignment broadcasts over the party chat control channel (view id plus icon index, the summon-notice pattern); rendering hooks CharacterNameplate, which already carries a party-specific font and atlas hook, and the target frame. Marks expire on target death or despawn and clear on scene change. Resolution is by view id, which all clients in the scene share; a member outside the scene simply does not render the mark. Icon set: six marks, drawn in the game's own iconography, no colors that collide with the PvP flag palette.

client Sserver noneperf one sprite per marked targettests mark registry model tests

S6 · Trusted-party toggles

Tier 1Size SServer: none

One options block: accept summons from my party without asking, accept teleport-to confirmations from my party without asking. You said yes to these people when you joined their party; the game should stop asking again mid-fight. This is consent design in the direct line of UO's party can loot me flag: say it once, per relationship, not per event.

Seen in: UO Publish 5's per-player party consent flags (April 2000); the auto-accept canon everywhere since.

Implementation notes

New booleans in Options.PartyOptions beside AutoDeclinePartyInvites, consumed where the dialogs fire in the presence-info receive path and UIManager.ShowPartySummonConfirmationDialog. The server-side gates (presence blocking, social block, offline checks) are untouched and stay authoritative; this only skips the client's own confirmation for senders who are currently party members. The admin summon path is distinct and stays distinct: the Summon Party scroll's history carries a written warning against re-splitting client and server halves, and this proposal touches only the client dialog.

client Sserver noneperf nonetests dialog-gate predicate tests

S7 · Auto-accept invites from friends and guildmates

Tier 1Size SServer: none

The mirror of the auto-decline option that already ships: party invites from your friends list or your guild skip the dialog and land you straight in the party, with a chat line saying so. At this population the person inviting you is almost never a stranger; the dialog is ceremony between people who play together every night.

Seen in: the ESO and WoW quality-of-life canon; the logical inverse of SotA's own AutoDeclinePartyInvites.

Implementation notes

A sibling option in Options.PartyOptions; the check runs in the invite receipt path in PartyManager against SocialListManager.GetFriends() and GetGuildMembers(), then answers through the existing AcceptInvitation. The battleground force-decline wins unconditionally: entering the Obsidian Trials already leaves your party and declines invites, and that rule stays on top.

client Sserver noneperf nonetests accept-gate predicate tests

S8 · Party row quick actions

Tier 1Size SServer: none

Right-click a party row for the verbs you always want: whisper, teleport to, promote to leader, make master looter, kick. Every one of these exists today, scattered across the Social tab, the teleport picker, and slash commands; the row is where your eyes already are. One boundary is law: rows navigate and manage, they never cast. The life-magic page rejected click-to-cast party frames, healing happens in the world, and that ruling stands.

Seen in: UO's classic-client per-member tell buttons (2000), a QoL its own Enhanced Client famously dropped; FFXIV's party list menu.

Implementation notes

PartyMemberUI rows already click-to-target; the menu follows the Social window's row-menu pattern (it has its own test suite to extend). Actions call the existing PartyManager.SetLeader, SetMasterLooter, Kick, and the teleport path in TeleportTargetModel, where party members already rank first. Leader-gated items render disabled for non-leaders; the server enforces regardless.

client Sserver noneperf nonetests row-menu action map tests

S9 · Link-dead countdown

Tier 1Size SServer: none

When a member disconnects, their row currently shows a bare offline state and nothing else. The system underneath is actually generous: a crashed player's seat is held for twenty minutes before the party stops waiting. Show it: "link-dead, seat held 18:32", counting down. The party learns the game's own rule, and nobody re-invites someone whose client is still rebooting.

Seen in: EverQuest's link-dead culture (1999); Deep Rock Galactic's leave-nobody-behind ethos.

Implementation notes

The disconnect event already reaches PartyManager and flips the row's online state; the twenty minute figure is the PartyMember record's TTL, a shared constant. The label renders beside the existing other-scene location label on PartyMemberUI. Client clock and server TTL drift, so round to the minute and prefix with a tilde.

client Sserver noneperf one labeltests countdown format tests

S10 · Surface the finder

Tier 1Size SServer: none

SotA has a party finder. It shipped, it works, it was rebuilt in UI Toolkit this July, and almost nobody knows it exists, because nothing in the game ever routes a player to it. Three cheap fixes: a /lfm slash command opens it, a live count badge on the social button says "3 parties recruiting", and a one-time login note appears when listings are active. This card invents nothing. It hangs a sign on a door we already built.

Seen in: DDO's LFM panel, one keypress away at all times; Old School RuneScape's lesson that visibility is the feature.

Implementation notes

Slash entry beside /p in the chat command switch; the window is PartyAdvertisementWindow. The count comes from the advertisement store PartyManager.advertisements, which fills from the existing subscription. Do not hold a standing subscription just for a badge: poll on social-window open plus a slow timer, keeping group-server publish volume flat. Also wire the one dead response path from S1 so subscription stop works. Server-side listing segregation (the hell-ban and bot filters) continues to apply untouched.

client Sserver noneperf badge polls, no standing subtests PartyAdvertisementConversionTests

S11 · The party toast

Tier 1Size SServer: none

/toast: you raise a mug or a blade, a callout lands in party chat, and any member who answers within ten seconds joins a small synchronized flourish. No buff, no bonus, no mechanics. Deep Rock Galactic built one of the most loyal communities in games on a salute button; Sea of Thieves did it with grog and shanties. Rituals are how a group of players becomes a crew, and they cost almost nothing to ship.

Seen in: Deep Rock Galactic's salute (2018), Sea of Thieves' grog and shanties, and every tavern scene in the fiction.

Implementation notes

The command joins the /partner and /mimic family: emote trigger plus a join-window broadcast over the party chat control channel. The synchronized flourish reuses the paired-emote machinery those commands already exercise, with its test suite as the template. Deliberately useless; keep it that way.

client Sserver noneperf nonetests join-window model tests

Tier 2 · Core upgrades

Everything in this tier rides one of two existing rails: the per-member property bag (four keys today, published by each member, rebroadcast unread by the server) or the party chat control channel. No new network operations anywhere in the tier.

S12 · Cross-scene vitals

Tier 2Size MServer: none, bag keys

Party members in another scene stop being a gray name and a town label: their rows keep health and focus bars, adventurer level, and an away flag, updated on meaningful change. This is the tile promise taken literally, what a party can do together beyond standing in the same scene, and it is the single change that makes a split party still feel like one thing.

Seen in: UO's 2000 party manifest showing every member regardless of screen; every raid frame since.

Today
Tirrag
Cora Cuz'avich
Soltown
Proposed
Tirragready
Cora Cuz'avichSoltown
Implementation notes

The one sanctioned extension point: new one-character keys in PartyMemberParameter beside rprp, oml, lro, and gms, published through the existing Request_UpdatePartyMemberProperties and rebroadcast free by OnPartyMemberPropertiesChanged. The server stores and forwards the bag unread; no server logic changes. Consumed in PartyMemberInfo and the bars-versus-label swap in PartyMemberUI.

Cadence is the whole risk: today the bag publishes on presence change only. Add change-driven publishes with hysteresis, five percent health steps, minimum two seconds apart, riding the existing quarter-second send throttle. Two rules are law: never rename an existing key (lro is persisted in member records; renaming silently resets everyone's opt-out), and new keys go last. This transport pattern is what S19 and S22 reuse.

client Mserver none (bag keys)perf hysteresis-gated publishestests bag round-trip + cadence tests

S13 · In-scene party markers

Tier 2Size MServer: none

Compass ticks and screen-edge arrows for party members in your scene. There are none today, anywhere; the only in-world party locator in the whole game is one label on the overworld map. "Where are you?" is the most-typed sentence in any party, and Ultima Online answered it with radar dots twenty-six years ago.

Seen in: UO Publish 5 radar dots (April 2000); the compass and minimap canon everywhere since.

Implementation notes

Positions already replicate in-scene through the player movement property on the unreliable channel; the member set comes from the existing scratch-list helpers. Render as a UITK layer parented like PartyUI's owned document; colors follow the established party name-color. The trap: spatially culled members have no entity to read, exactly the case PartyMemberUI.FindEntity already handles, so markers degrade to last-known position with a staleness fade, then hide. Do not fight the culler.

client Mserver noneperf N markers, N max 11tests marker state model tests

S14 · Overworld party markers rebuilt

Tier 2Size MServer: none

The overworld party marker is the last NGUI holdout in the entire party stack: a world-space label with a ground raycast, from another era. Rebuild it in UI Toolkit, give it a staleness fade (the position only updates when a member changes scene), and let clicking it show the member's destination. Finishing this retires party UI from the NGUI migration ledger entirely.

Seen in: UO's world-map party dots (2000); table stakes since.

Implementation notes

The current stack is OverworldParty plus OverworldPartyMemberUI and its prefab; position data is the oml bag key, already fed by the player controller from the hex map. Record the conversion in the NGUI-to-UITK progress doc like every prior batch. Shares its art and interaction model with S13.

client Mserver noneperf improves (retires world-space NGUI)tests conversion parity tests

S15 · Pins and pings

Tier 2Size MServer: none

Drop a numbered pin in the scene or on the overworld: regroup here, boss room, loot the cart. Members see pins on the S13 marker layer and hear a soft tick when one lands. Display-only and deliberately client-trust: the server famously knows no player positions, and nothing about a pin needs to be authoritative.

Seen in: GW2's squad markers (2015); the ping canon from every co-op game of the last decade.

Implementation notes

Pin payload rides the party chat control channel: position, icon index, sender. Scene pins expire on the sender's scene change (the presence-props event already fires there); overworld pins reuse the oml hex coordinate space. Leader can clear all. Depends on S13's render layer and S5's icon set.

client Mserver noneperf nonetests pin lifecycle model tests
Oil painting of a hooded traveler pinning a notice to a weathered board outside a tavern door, a dog sleeping on the step
The oldest interface in the genre. Wizardry put the party-forming tavern in a computer in 1981; two thirds of tabletop campaigns still start at one. SotA's player-run taverns are waiting for the board.

S16 · The Adventurer's Board

Tier 2Size LServer: none, property bag

The Looking For More window grows from a bare list into a real board: activity tags (hunt, boss, quest line, crafting circle, performance, new players welcome), a target scene, a starts-at time, and ask-to-join with a short message. This is the sanctioned low-population answer, and the whole page turns on the distinction: a board with three listings still works, and advertises that people exist; a queue with three people is a broken feature. The guild finder, built and shipped in August, is the exact template. The music page's gig board folds in here by prior agreement.

Seen in: FFXIV Party Finder (December 2013), WoW's premade Group Finder board (2014), DDO's LFM panel, OSRS recruiting boards.

The Party Board
FilterAll activitiesHuntsQuestsNew playersRefresh
ListingPartyWhere
Clearing the Rise. All welcome. Roll at 500 gold.5 of 8Upper TearsAsk to join
Ore run, bring a pick. We teach.2 of 4Elysium MinesAsk to join
Story run, Necropolis quest line. Mentor leading.1 of 6NecropolisAsk to join
No listing fits?Post our listing
Implementation notes

Structured fields land as new one-character keys in the party properties bag (PartyPropertiesExt.PropertyKeys): the server stores and rebroadcasts the bag unread, so this is client plus shared key constants only, riding the existing set-properties and looking-for-more-changed operations. Tags are a bitfield, not strings; the advertisement republishes on every mutation, so keep the payload flat. UI rebuilds PartyAdvertisementWindow and its model, extending the existing conversion test suite. One honest limit stated on the card: live listings still die with the party's twenty minute TTL. The listing that outlives the party is S27, and this card does not promise persistence.

The dormant hook worth finishing here: PartyLFMFilter is defined, stored, and threaded through every server op, and the client never sets it. Tag-driven filters should finally put it to work.

client Lserver none (bag keys)perf bitfield tags, flat payloadtests PartyAdvertisementConversionTests

S17 · Open party

Tier 2Size MServer: none

A party flags itself open, and anyone in the same scene sees it: a line in the players-in-scene window, a small mark on the leader's nameplate, join in one click, no invite ceremony. Two strangers hunting the same low-population scene should merge, not circle each other. Warhammer Online proved the pattern in 2008; Sea of Thieves runs a whole game on it.

Seen in: Warhammer Online's Open Party (2008), RIFT's public groups (2011), Sea of Thieves' Open Crew.

Implementation notes

Implemented as a Looking For More advertisement carrying a walk-up tag bit, so the join path is the existing advertised-party flow through Request_JoinParty, and the server's listing segregation applies for free. Surfaced contextually: the players-in-scene window matches the advertisement's scene tag against the current room. Verify the server's join gate behavior when no advertisement is active and keep the requirement client-side regardless, for consent. Depends on S16's tag bits.

client Mserver none (rides LFM)perf nonetests scene-match predicate tests

S18 · The signal arrow

Tier 2Size LServer: none

Mid-fight and outmatched? Fire a signal arrow: an urgent, short-lived board listing, "LIVE: fighting the troll at Blood Bay, two of us, come now", that fast-tracks responders into the party and immediately offers them the teleport-to-member path. It converts solo players into party players at the exact moment they want company, and because joining the party drives instance convergence, it works across the game's three multiplayer modes. Monster Hunter turned this single verb into its whole co-op culture.

Seen in: Monster Hunter World's SOS flare (2018) with its anti-leech window; WoW's summoning stones.

Implementation notes

Pure orchestration of existing operations: create-with-advertisement carrying an urgent tag, auto-accept of responders, then the existing teleport-to-member presence path, where party already ranks first. The countdown problem is real: the party instance drift loop takes about a minute, but an explicit matchmaking change rides a ten second path, and responders should take it. Flares expire client-side after ten minutes, the Monster Hunter rule, so the board never fills with dead emergencies. Every server-side gate (presence blocking, hell-ban, offline) stays authoritative and untouched. Depends on S16 and S17; S6's trusted-party auto-accept makes answering frictionless.

client Lserver none (orchestration)perf nonetests flare lifecycle model tests

S19 · Named parties

Tier 2Size MServer: none, bag key

The leader names the party, "The Lantern Company", and the name heads the party HUD, titles the chat tab, and leads the board listing. A named thing is a thing people want to keep. The fiction is unanimous here, and it is not close: the Fellowship was named before it walked a mile, Kurosawa's samurai fought under a painted banner, and Critical Role's players named their party before the world ever learned theirs.

Seen in: Vox Machina naming itself (2015, first draft rejected); Seven Samurai's banner; distinct from SotA's shipped band tokens, which are a performance grouping, not the party's identity.

Implementation notes

A new one-character key in the party properties bag, leader-set through the existing set-properties operation, which the server already enforces leader-only. Displayed in the PartyUI header, the chat tab label, and S16 listings. Names run through the same redaction pipeline chat uses before display. Honest limit: the name dies with the party's twenty minute TTL, and the card says so; making it durable is exactly S31's job, and this key is designed to migrate there.

client Mserver none (bag key)perf nonetests name validation + redaction tests

S20 · Round-robin loot

Tier 2Size LServer: none

A fourth loot rule beside free-for-all, Roll, and Master Looter: corpses rotate through the roster in join order, skipping anyone out of the scene. Fair, dumb, and zero-click, which is precisely the virtue; on a farming night, rolling on every wolf pelt is noise. WoW shipped this for trash loot on day one and nobody ever complained about it, which in loot design is the highest praise there is.

Seen in: WoW's launch round-robin (2004); the quiet middle of the genre's twenty-year loot pendulum.

Implementation notes

The loot rule enum is client-side only, and enforcement mirrors Master Looter's purely client gate (PartyManager.DisallowLooting feeding the corpse and chest interaction checks), so no server change. Whose turn it is derives deterministically from corpse identity plus actor-number order, the seniority ordering the whole system already uses, tie-broken by the corpse's synced ownership buffer. On any ambiguity, degrade to free-for-all for that corpse; never lock loot. Two standing rules: the gold-share list is deliberately separate from the roll list and stays that way, and the roll eligibility builder must keep returning null rather than an empty array (the server's bonus math throws on empty; the opt-out test suite pins this).

client Lserver noneperf nonetests rotation model EditMode suite

S21 · The expedition ledger

Tier 2Size MServer: none

A running session tally per party: gold shares received, rolls won and lost, XP taken in, kills, deaths, resurrections given, and a summary card when the party disbands. Today a party simply evaporates; the ledger is both the fairness receipt and the missing goodbye. It is labeled what you witnessed, not an audit, because the client only counts what reached it.

Seen in: Sea of Thieves' voyage tallies, Monster Hunter's result screens, the tabletop tradition of the company ledger.

The Lantern Company disbands
Together for2 h 41 m
Kills witnessed214
Your gold shares1,862
Rolls won3 of 11
Resurrections: Mondravis raised you twice.
Implementation notes

Pure client aggregation of events already arriving: the gold share chat line's data, the roll-resolved broadcast, the party loot notification RPC, the S3 receipt lines, and the leave and disband events. The summary renders off the disband path, which the client already distinguishes from a kick. Feeds S28's commendation prompt and, later, the Company chronicle.

client Mserver noneperf counters onlytests ledger accumulation tests

S22 · Mentor's mark

Tier 2Size MServer: none

The game already mentors in secret: stand near a party member who has Grandmastered the skill you are training and you learn at the apprentice rate. Nobody knows, because nothing shows it. Surface it: a laurel on the mentor's row, a quiet "learning from Tirrag" note on your skill gains, and an open-to-mentor tag on board listings. SotA's veteran-heavy population is the asset here, not the problem; the game just never says thank you.

Seen in: FFXIV's mentor crown and Novice Network, GW2's zero-mechanics mentor tag (2015), EQ2 mentoring (2004).

Implementation notes

The bonus logic lives in CharacterData: a nearby party Grandmaster flips the learning tier. Grandmaster skill data is already in scene, and the cross-scene count already travels as the gms bag key with privacy zeroing respected; a hidden Grandmaster shows nothing, and that stays. The board tag is one S16 bit. This card is a lens on existing math; the paid half is S29.

client Mserver noneperf nonetests mentor-visibility predicate tests

S23 · The tavern muster

Tier 2Size Lcontent pipeline

A placeable adventurer's board for taverns and town squares: interact, and the Party Board opens. A matching long table lets a seated party's toast fire a room-visible flourish. The place where you form the party becomes a named location in the world, the oldest idea in the genre, running since Gilgamesh's Tavern in 1981, and SotA is uniquely equipped for it: this game has real player-run taverns, and they are mechanically inert.

Seen in: Wizardry (1981), The Bard's Tale's Adventurer's Guild (1985), Star Wars Galaxies' cantinas, the tavern-recruitment trope itself.

Implementation notes

Interaction follows the established interactive-object pattern (the corpse and chest gates are the template) and opens PartyAdvertisementWindow; the toast comes from S11. The deco items are content-pipeline data on both sides, new archetypes but no new server code. Scope discipline: version one is a door to the board plus the toast, nothing more; tavern gameplay is its own future conversation. Listings on the physical board are the same listings, filtered by the board's town as a default.

client L (mostly art)server content onlyperf nonetests interaction gate tests

Tier 3 · Server-backed, each with its exact cost

Ground rules for this tier, stated once. A new request added to the existing party interface means a new opcode, a new entry in the existing party dispatch, and a regenerated RPC table, but no new interface wiring. A brand new interface group means manual dispatcher wiring in the group server's request router, the one step the code generator does not do. Any new server file must be registered in both server project files. Any durable database change owes the migrations ledger an entry in the same commit. Every card below names which of these it pays.

S24 · Anyone-may-invite

Tier 3Size Sone permission check

A party setting that lets every member invite, not only the leader. With two to four people online of an evening, "wait until the leader is back from the bank" is a real tax on the only thing a small game needs: parties growing. The leader keeps kick and settings; the doors just get more handles.

Seen in: WoW's everyone-invites default; UO's leader-only /add as the cautionary ancestor.

Implementation notes

The flag is a party properties bag key set by the leader. Server: the invite handler's permission check in Party consults the flag alongside the role-permission map, which today grants invite rights to the Leader role only; the role map in the shared enums extends in place and mirrors. No new operation, no database shape change, no dispatcher wiring. The client's own pre-check that rejects non-leader invites must relax in the same change, or the server work is invisible.

client Sserver one check in Party.csdb nonetests bot-client invite matrix

S25 · A wider share circle

Tier 3Size Stweak default

Raise the XP and loot-notification share radius from twenty meters to roughly forty. Scouts, pullers, and the friend looting the last room stop silently earning zero. The in-scene requirement stays; only the circle grows. Paired with S2's link light so the rule is finally visible at the same moment it becomes generous.

Seen in: the genre's steady drift from EverQuest's tight camps to GW2 and ESO's generous participation credit.

Implementation notes

One tweak-value default, mirrored: the squared-range constant consumed by the XP award path, the roll eligibility list, fishing, and loot notifications, all through the same helper. Anti-leech bounds already exist structurally: the same-scene requirement, the twelve-member cap, and the party-size bonus cap. Ship after S2 so players can see the circle they stand in.

client noneserver one mirrored constantdb nonetests existing paths, new bound

S26 · Need before greed

Tier 3Size Mop params + RpcList

The d100 loot roll grows two buttons: Need, I will use it, beats Greed, I will sell it, beats Pass. The single most-copied loot compromise in the genre, and the one WoW came all the way back to in 2022 after fully automating loot and regretting it. SotA's roll machinery is one answer-enum wider than this feature.

Seen in: WoW's need-before-greed (2004), restored as the raid standard in Dragonflight (November 2022); the pendulum's resting point.

Implementation notes

Client: the roll window gains the two buttons and tier labels in the result line. Server: the roll resolver buckets answers, Need pool rolls first, existing tie re-roll logic kept per bucket; the answer parameter on the existing roll-answer operation widens. Existing operations, new parameter values, RPC table regeneration required; no new group, no database. Version skew: old clients send the binary answer, which maps to Need, and the new UI gates on the build-number mismatch detection that already runs in the party. The eligibility list, and its null-not-empty invariant, is untouched.

client Mserver roll buckets + RpcList regendb nonetests bucket resolver + legacy-answer cases

S27 · The persistent adventure board

Tier 3Size Lnew collection + ledger

Posts that outlive the party and the session: "Saturday 8pm, Upper Tears champion hunt, four slots, sign here." Members sign asynchronously across the week; at start time, forming the actual party is one click per signature. This is the low-population group finder in its final form, asynchronous and cross-day, working even when three people are online, and it fully absorbs the music page's gig board. It also answers, honestly and without a queue, the forum's standing request for organizable scenario play.

Seen in: FFXIV Party Finder's persistent listings; OSRS's out-of-game board ecosystem, the lesson being to put the board where players already look.

Implementation notes

The first card that pays real storage: a new durable collection (poster, text, tags, start time, signatures, day-scale TTL), which owes the migrations ledger its entry in the same commit. New request and response methods join the existing party interface group: new opcodes, new entries in the existing party dispatch, RPC table regeneration, but no new interface wiring. The handler lives beside the party logic on the social server; if it lands as a new file, both server project files register it. Listing text runs the chat redaction path; expiry follows the invite-timeout sweeper pattern. Forming rides the existing create-with-invite and invite operations. A read-only web mirror on the community site is a natural stretch, with the proposals API as the infrastructure precedent.

client L (board tab)server new ops on IPartyRequestdb new collection + ledger entrytests signup lifecycle + expiry sweeper

S28 · Raise a glass

Tier 3Size Mop + durable stat

When a party ends, you may commend one companion from the session: steady hands, generous, good company. Commendations accrue on the character, feed titles, and later gate the mentor kicker. Player commendation is the one positive reputation system the genre ever got right, and it matters most on a small server, where reputation actually travels.

Seen in: FFXIV's Player Commendations (2013), feeding mentor eligibility; nothing else in the genre worked as well.

Implementation notes

The prompt hangs off S21's disband summary, with the recipient picker from the last roster snapshot. One new request on the existing party interface group (opcode, dispatch entry, RPC regeneration; no new wiring), handled on the social peer with server-side rate limits. Storage rides the durable character-stat machinery if a stat fits; if it needs a field on a durable record instead, that is a migrations ledger entry, and the card budgets for it. Farming is the entire risk at low population: one commendation per companion per day, none for parties under three, a weekly ceiling, and counts private by default following the Grandmaster-privacy precedent.

client Mserver new op on IPartyRequestdb stat or ledger entrytests rate-limit matrix

S29 · The mentor's kicker

Tier 3Size Mone XP-loop term

When a veteran parties with a genuinely new player, the veteran earns a small additive XP bonus, five to ten percent, and the newcomer keeps their normal full share. No level sync, no penalty, no charity math: SotA's flat split already lets a decade-old character and a week-old one hunt together, which is exactly why the genre's level-gap penalty models were rejected here. This card simply pays the shepherds in the currency they still care about.

Seen in: EQ2's mentoring bonus (2004), FFXIV's mentor XP bonus for grouping with sprouts; the population-friendly end of the design space.

Implementation notes

One additive percent term in the sanctioned XP-loop insertion point, exactly where the open-multiplayer and PvP bonuses already assemble, additive-on-100 by that code's own design note. Newcomer detection is server-side from account data on the target peers, no client trust and no new RPC; gate on account age, not character age, against alt farming. No database change if newcomer is an account-age test; a persisted mentor-eligibility flag, if S28-gating is wanted later, would owe the ledger. Surfaces in S3's receipt and S22's mark.

client display onlyserver one bonus termdb nonetests bonus assembly cases

S30 · Announce the company

Tier 3Size Sone payload field

When a named party fells a boss, the world hears the name: "The Lantern Company has defeated the Dragon of Etceter." One string, enormous identity payoff. This lands as a rider on the achievements page's in-flight super-boss announcement, which already carries the party's size; this card adds the name beside it, and adds nothing else.

Seen in: UO's champion-spawn town-crier spirit; every raiding guild's server-first screenshot.

Implementation notes

The boss-defeated world event emit already attaches party size; the name comes from S19's bag key, read server-side from the party storage record by the attributed party id, one database read on a boss kill only. Coordinate with the achievements card's formatter and its 32 KB roster-encode limit: the name travels, never the roster. Redaction from S19 applies before broadcast. Sequencing is honest: if the achievements card has not built, this waits for it.

client noneserver one field on an in-flight emitdb nonetests formatter cases

S31 · The Company charter

Tier 3Size XLnew group + 2 collections

The flagship. A party swears a charter and becomes a Company: a persistent named fellowship of two to twelve, with a sigil, a motto, a founding date, and a roster that survives logout, patches, and months apart. "Muster the company" re-invites every member currently online in one click; the charter page keeps the chronicle. It is not a guild, and the page draws that line hard: the guild is the institution, the company is the Fellowship-sized cadre inside or across guilds, the same way band tokens already cross guild lines. Today every party in this game dies in twenty minutes. The fiction says the party is the most durable thing in the story. The fiction is right.

Seen in: the Fellowship sworn at the Council of Elrond; Seven Samurai's recruited, bannered company; UO New Legacy making group identity the prize (2024); Deep Rock Galactic's crew retention.

THE LANTERN COMPANY
RosterBoardRulesCharter
NameThe Lantern CompanySigilLanternGold
MottoWe go in together
Founded 15 Aug 2026 by Tirrag
Chronicle
15 Aug 2026Company founded in Soltown.
15 Aug 2026Defeated the Troll of Blood Bay. Five members present.
14 Aug 2026First clear: Upper Tears, all rooms.
Muster the company3 of 5 online
Implementation notes

The one card that pays the full stack, every flag flying: new company request, response, and event interface groups beside the party's, which means manual dispatcher wiring in the group server's request router, the step the generator does not do; a new authoritative Company class on the social server modeled on the party's fiber pattern, registered in both server project files; two new durable collections, company and company-member, with no TTL, each owing the migrations ledger; RPC table regeneration; and the shared wire mirror extended in place. Client side, a CompanyManager modeled directly on PartyManager, with the charter as the fourth tab of the composed window in Section 4. Muster calls the existing create-with-invite and invite operations per online member.

Scope discipline for version one: identity fields and the muster button only. Deed recording into the chronicle rides the achievements page's in-flight party-credit ledger when that builds; this card does not own it. A character holds one guild and at most one company.

client XLserver new groups + wiring + Company.csdb 2 collections + ledger entriestests bot-client company lifecycle

S32 · The company banner

Tier 3Size Lrides S31 schema

The sigil made physical: a banner plantable in the field during a hunt, placeable in housing, hangable over the tavern table. Heihachi painted six circles and a triangle on a flag, and a village fought under it. In a game whose economy runs on player housing and player towns, the company banner is the most natural object this page proposes, and the most illustratable.

Seen in: Seven Samurai (1954); GW2 commander tags as battlefield identity; mercenary colors throughout the fiction.

Implementation notes

Sigil composition is a pattern plus colors from a fixed palette, stored on S31's company record, no additional migration if designed into that schema from the start, which this card is the reminder to do. The field banner follows the synced-ownership placed-object pattern the PvP ransom system already uses; the housing version is standard deco pipeline. The field banner renders on S13's marker layer as a rally point. Explicitly out of scope: teleport-to-banner, because the server knows no positions and rally teleportation would be client-trust; the rejection list carries it.

client L (art + deco)server none beyond S31db in S31's schematests sigil round-trip

S33 · The muster

Tier 3Size XLencounter logic

Walk into a control point as a party and the encounter answers in kind: wave counts and elite density scale to the players present, escalating to a boss worth announcing. This is the page's content anchor and a direct, credited answer to the forum's champion-spawn thread, which asked in so many words for parties entering together, escalating waves, and a boss with a real payout, and to the standing request for a high-health world boss. Distinct on purpose from the PvP page's Oracle's Trials, no queue and no sides, and from the towns page's event cages, this is open-world PvE that finally notices how many of you came.

Seen in: UO's champion spawns (2001), the genre's first mass open-world group ritual; GW2's scaling dynamic events; Monster Hunter's join-scaling.

Implementation notes

Attribution and payout ride the existing machines end to end: corpse ownership from party damage attribution, XP through the standard award path, the announcement through the boss-defeated world event with S30's name. The new work is game-server encounter logic: spawner scaling keyed to peers in the game instance, which the server does know, never to client-claimed party size, mirroring the philosophy of the existing open-instance XP anti-exploit. New server files register in both project files; no new RPC group; no database, with record plaques riding the dungeon-plaque precedent if wanted. The real cost is tuning, and the card says so.

client none requiredserver encounter scaling logicdb nonetests scaling curve unit tests

S34 · Hired blades

Tier 3Size XLembodied-bots epic

When only two of you are online, hire a pair of blades at the tavern: bot companions that fill party slots, fight competently, and take a cut of the gold, the honest mercenary tax. This is the only pattern that makes party-tuned content designable at a small population, and the machinery is closer than it sounds: the party system already carries a complete bot lane, from bot listing filters to bot-party fast-disband, and the server's bot harness already passes party integration tests.

Seen in: Guild Wars henchmen and Heroes (2005, 2006), which solved the empty-slots problem for a decade; FFXIV's Trust and Duty Support; WoW's Follower Dungeons (2024); EverQuest's mercenaries and their XP tithe (2010).

Implementation notes

Gated on the embodied-bots program, whose ledger owns bot spawning and control; this card's own party-side cost is modest, with bots joining as real members through the normal lifecycle the server already special-cases, rows rendering like any member, and the gold tithe riding the existing gold split with the bot's share sunk. The hiring operation is one new request on the existing party interface. The measured limit is the client: bot-crowd profiling pegged the main thread long before the server or GPU blinked, so the card promises two or three companions, never armies, and combat competence is the make-or-break. S23's tavern is the hiring surface; S33 is its best customer.

client rows render freeserver one op + the epic's own ledgerdb the epic'stests bot-party lifecycle exists, extend

Considered and rejected

Section 4

The Company Window

The danger with thirty-four proposals is a screen with thirty-four widgets. The composition rule: everything lands in exactly three places. One window, the Company Window, four views under one header, replacing the scattered Party tab, the orphaned finder window, and the options fragments on three tabs. One satellite, the existing HUD column, which gains only glanceable glyphs and never casts. One world layer, the compass marks, pins, and the tavern board. Here is the window at its default size, wired to the real feature set:

THE LANTERN COMPANYMembers 5 of 12  
RosterBoardRulesCharter
MemberHealthFocusWhereReady
TirragThis sceneyes
MondravisThis sceneyes
Cora Cuz'avichSoltownnot yet
AkandrielOverworldyes
RinaldiLink-dead. Seat held 18 minutes.
Invite a player by nameSendReady checkCall for help
Open party: on. Anyone in this scene may join.Learning from Tirrag: Blades
RegionContentsWhy it lives here
Header bandCompany name, member count of twelveIdentity always visible; the name is the emotional hook on every view (S19, S31).
Roster viewRows with vitals, location, ready state; right-click verbs; link-dead countdownMirrors the HUD column's ordering so the two never disagree. Rows select and manage; casting from frames is rejected law (S2, S8, S9, S12).
Board viewListings with tags, scenes, times; post-listing; urgent flares float to topThe discovery surface, backed entirely by the shipped LFM operations (S16, S17, S18, S27).
Rules viewLoot rule, threshold, master looter, the XP readout with the share range, consent blockEverything a party argues about on one page, with leader-only fields visibly locked; ends the three-tab options scatter (S6, S20, S25, S26).
Charter viewName, motto, sigil, chronicle, muster button, banner craftingThe durable layer, the only view backed by new storage (S31, S32).
HUD satelliteExisting column plus ready dots, mark glyphs, cross-scene barsGlanceable only; hosts the life-magic page's healer marks later; never a casting surface.
World layerCompass marks, edge arrows, pins, the tavern board, the planted bannerThe party's presence in the world itself (S5, S13, S14, S15, S23, S32).
Section 5

Sequencing

PhaseShipsServerWhy this order
1S1, then S2, S3, S9, S10, then S4–S8, S11noneRepair and reveal. Bug fixes clear the ground; the fairness and finder machinery that already exists becomes visible before anything new is built. The missing party systems doc gets written here.
2S12, S13, S14, S15nonePresence. The member bag pattern lands first (S12) because S19 and S22 copy it; the party becomes one organism across scenes.
3S16, S17, S19, S22, then S18; riders S24, S25two trivial changesFinding. One coherent Adventurer's Board release, framed as growing the shipped finder, never as introducing one. The two near-zero server riders land with it.
4S20, S21, then S26, S27, S28, S29, S30ops on existing groups; first new collectionFairness and memory. The first real server beat: need-before-greed, the persistent board with its ledger entry, commendations, the mentor kicker. S30 waits on the achievements announce card.
5S31, S32, S23, S33, S34the full stack, onceIdentity and the big swings. The Company pays the new-group wiring cost once and everything identity-shaped funnels into its schema; the tavern lands best when companies exist to sit at the table; the muster and the hired blades are the long game.
flowchart TD
  S1["S1 plumbing repair"] --> T1["Tier 1 QoL wave"]
  S10["S10 surface the finder"] --> S16["S16 Adventurer's Board"]
  S16 --> S17["S17 open party"]
  S16 --> S18["S18 signal arrow"]
  S16 --> S27["S27 persistent board"]
  S5["S5 target marks"] --> S15["S15 pins + pings"]
  S13["S13 scene markers"] --> S15
  S13 --> S32b["S32 field banner render"]
  S12["S12 bag-key pattern"] --> S19["S19 named parties"]
  S12 --> S22["S22 mentor's mark"]
  S19 --> S30["S30 announce the company"]
  S19 --> S31["S31 Company charter"]
  S21["S21 ledger"] --> S28["S28 commendations"]
  S28 -.optional gate.-> S29["S29 mentor's kicker"]
  S22 --> S29
  S31 --> S32["S32 banner"]
  S11["S11 toast"] --> S23["S23 tavern muster"]
  S16 --> S23
  EB["embodied-bots epic"] -.gates.-> S34["S34 hired blades"]
  S34 -.serves.-> S33["S33 the muster"]
  A18["achievements announce card"] -.gates.-> S30
Section 6

Appendix

A1 · Why Tiers 1 and 2 cost the server nothing

RailWhat it isCards riding it
Member property bagPer-member key-value bag, four keys today, published by each member through an existing operation, stored and rebroadcast unread by the server. The loot-roll opt-out shipped exactly this way.S12, S19, S22 (read), plus S16's party-level sibling
Party chat control channelThe party chat channel already carries out-of-band control messages beside text (the summon countdown does this today). New keys are client-defined.S3, S4, S5, S11, S15
Existing party operationsFourteen requests, thirteen responses, eleven events, all live. The finder, join, invite, and properties paths cover the discovery tier without new opcodes.S10, S16, S17, S18, S20, S21
Scene replicationHealth, focus, effects, and position of in-scene members already replicate to every client.S2, S13, S14

A2 · Constraints every proposal honors

A3 · Test surface

Four party suites exist and get extended rather than duplicated: instance ownership, loot-roll opt-out, HUD model, and finder conversion. The pure-logic pieces here, the rotation model, the flare and pin lifecycles, the receipt formatter, the commendation rate limits, the mentor predicates, are all EditMode-testable with no scene objects. The known gap this page inherits: the social server's party lifecycle itself has no EditMode coverage and relies on the server-side bot tests; S31's company work should bring its own bot-client lifecycle suite from day one.

A4 · Requester credits

Tirrag asked for the loot-roll opt-out that shipped in July and anchors this page's consent thread. The champion-spawn revamp thread asked for parties entering together, escalating waves, and a boss with a real payout: that is S33, directly. The high-health world boss thread feeds the same card. Akandriel's request for organizable scenario play is answered by the persistent board (S27) and the muster (S33), deliberately without a queue. Mondravis and Rinaldi, whose reports sharpened the taming and XP-fairness work this page builds on, appear in its mockups. Thank you for writing it all down.

A5 · Selected sources

UO: the party system and Publish 5, 18, and 74 notes on uo.com and UOGuide; champion spawn and New Legacy coverage. EverQuest: the Project 1999 grouping guide and mercenary documentation. City of Heroes: sidekick and Issue 16 documentation. WoW: patch archaeology for 1.11, 3.3, 6.0.2, 8.2.5, and 10.2.5, and the Dungeon Finder debate coverage. FFXIV: Party Finder, Trust, mentor, and commendation documentation. GW2: dynamic events and the Enhanced Squad UI announcement. Also: the DDO social panel, OSRS boards, Monster Hunter SOS documentation, Deep Rock Galactic and Sea of Thieves community histories, BG3 co-op guides, Wizardry and Bard's Tale histories, and on the fiction side, the Council of Elrond, Seven Samurai, and the Critical Role archives. Full URL list in the research notes accompanying this proposal.

Prepared 15 August 2026 against the unity-6.5 migration branch. Companion markdown: docs/plans/2026-08-15-party-grouping-improvements-proposal.md. Thirty-four proposals: eleven quick wins, twelve core upgrades on existing rails, eleven server-backed with their costs in the open.

Feedback

General comments

No account needed. Every proposal above also has its own Discussion box for talking about that one alone; this thread is for the plan as a whole. Comments are plain text, held to basic decency, and may be trimmed.

← All proposalsWork blog