diff --git a/overlay/Config/Bridge.cfg b/overlay/Config/Bridge.cfg index ef09957..0245269 100644 --- a/overlay/Config/Bridge.cfg +++ b/overlay/Config/Bridge.cfg @@ -48,6 +48,83 @@ PresenceSweepSeconds=30 # house.remove (owner, region, location, decay). Houses change slowly; a few minutes is fine. HousingSweepSeconds=300 +# Points / loyalty leaderboards (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §7). ServUO carries ~25 point +# currencies (Queen's Loyalty, Void Pool, Casino, Clean Up Britannia, the nine city loyalties, +# the Doom/Khaldun/Kotl treasure systems, …). Each is diffed on this interval and emitted as +# one points.board frame per system when its top N moves. +# +# Slow on purpose: these are month-scale standings, and ten of the systems keep a row for +# every character ever created, so the pass is the widest read in the bridge. It is still +# cheap — a single bounded pass, never a sort — but there is nothing to gain by hurrying it. +PointsSweepSeconds=300 + +# Master switch for the boards. Off leaves char.profile points alone (see below). +PointsLeaderboardEnabled=true + +# How many players per board. Clamped to 1..100 — the frame is emitted PER SYSTEM, so a big +# N is multiplied by ~25. +PointsTopN=10 + +# Which systems to publish, as a comma-separated list of PointsType names, e.g. +# PointsSystems=QueensLoyalty,CleanUpBritannia,VoidPool +# Blank (the default) publishes whatever the shard itself shows on the in-game loyalty gump +# (ShowOnLoyaltyGump), so a subsystem you add later gets a board without an edit here. +# An unrecognized name is logged and ignored, never silently dropped. +PointsSystems= + +# Include a per-character "points" block in char.profile (the website character sheet). This +# is a lookup across every published system's table, so it is the dominant cost of building a +# profile; turn it off on a very large shard that does not want the sheet paying for it. +PointsProfileEnabled=true + +# Also compute each system's rank in that block. OFF by default and worth leaving off: a +# points lookup stops at the character's own row, but a rank must count every row that beats +# them, in every system, on every profile build. The website already derives rank from the +# board for anyone in the top N. +PointsProfileRank=false + +# Player-vendor market index (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §8). Every player vendor's shop name, +# owner, location and priced inventory, published as one vendor.listing frame per vendor so the +# website can offer the search the in-game Vendor Search gump offers. Honours each player's own +# in-game opt-out (the vendor's VendorSearch flag) — hide your vendor in game and it is hidden +# on the site too. +MarketEnabled=true + +# Sweep interval. UNLIKE every other sweep here, a tick does NOT walk the whole world: it +# inventories at most MarketSweepBatch vendors and a persistent cursor round-robins through the +# rest, so the per-tick cost is bounded by the batch rather than by how many vendors exist. Full +# coverage takes ceil(vendors / batch) x MarketSweepSeconds — 500 vendors at the defaults is one +# complete pass every 20 minutes, and the site labels the data with how stale it may be. +# +# Lower this (or raise the batch) for faster coverage; both trade directly against per-tick cost, +# and the expensive part is the item walk, which recurses into every container a vendor is selling. +MarketSweepSeconds=60 +MarketSweepBatch=25 + +# Per-vendor listing cap, after which the frame carries "truncated": true. A commodity reseller +# with thousands of stacked resources is a real thing, and an uncapped frame for one is measured +# in megabytes. Clamped to 1..5000. +MarketMaxListings=250 + +# Shard ruleset (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §5). One world.ruleset frame — expansion, which +# systems are on, skill/stat caps, account and house limits, champion scroll rules — +# emitted on every sidecar connect (and on [bridge reload), so the website's rules page +# cannot drift from the server. Not a sweep: it changes only when you edit a .cfg. +# +# The frame is built from an explicit allowlist of keys in BridgeRuleset.cs. Server.cfg, +# Staff.cfg, Email.cfg, DataPath.cfg, Bridge.cfg, Compiler.cfg, Reports.cfg and Client.cfg +# are never read. +RulesetEnabled=true + +# The one connection detail the bridge will publish, e.g. play.myshard.com,2593. Blank +# (the default) omits it entirely. Server.cfg's Address/Listen/Port are NEVER published — +# if you want a connect string on the site, put it here deliberately. +PublicConnectAddress= + +# Include the save/restart schedule (AutoSave frequency, AutoRestart hour) in the frame. +# Turn off if you would rather not advertise a predictable restart window. +RulesetIncludeSchedule=true + # Shown to a player when they run [link. The website page where they enter the code. LinkUrl=https://yoursite/link diff --git a/overlay/Scripts/Custom/Bridge/BridgeBoot.cs b/overlay/Scripts/Custom/Bridge/BridgeBoot.cs index 4af7e27..c7e7f4b 100644 --- a/overlay/Scripts/Custom/Bridge/BridgeBoot.cs +++ b/overlay/Scripts/Custom/Bridge/BridgeBoot.cs @@ -165,8 +165,13 @@ namespace Server.Custom.Bridge BridgeGovernance.Rearm(); BridgePresence.Rearm(); BridgeHousing.Rearm(); + BridgePoints.Rearm(); + BridgeMarket.Rearm(); + // Not a sweep, so it has nothing to re-arm — but an operator who just edited a + // .cfg wants the change on the site now, not after a shard restart. + BridgeRuleset.Emit(); e.Mobile.SendMessage("Bridge: {0}", BridgeConfig.Describe()); - e.Mobile.SendMessage("Bridge: sweeps re-armed; endpoint changes take effect on reconnect."); + e.Mobile.SendMessage("Bridge: sweeps re-armed; ruleset re-emitted; endpoint changes take effect on reconnect."); break; case "ping": @@ -181,6 +186,8 @@ namespace Server.Custom.Bridge BridgeGovernance.SweepOnce(); BridgePresence.SweepOnce(); BridgeHousing.SweepOnce(); + BridgePoints.SweepOnce(); + BridgeMarket.SweepOnce(); e.Mobile.SendMessage("Bridge: ran one sweep of each stream."); e.Mobile.SendMessage("Bridge: {0}", BridgeSweeps.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgeChamps.Status()); @@ -188,6 +195,8 @@ namespace Server.Custom.Bridge e.Mobile.SendMessage("Bridge: {0}", BridgeGovernance.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgePresence.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgeHousing.Status()); + e.Mobile.SendMessage("Bridge: {0}", BridgePoints.Status()); + e.Mobile.SendMessage("Bridge: {0}", BridgeMarket.Status()); break; default: @@ -202,7 +211,10 @@ namespace Server.Custom.Bridge e.Mobile.SendMessage("Bridge: {0}", BridgeGovernance.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgePresence.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgeHousing.Status()); + e.Mobile.SendMessage("Bridge: {0}", BridgePoints.Status()); + e.Mobile.SendMessage("Bridge: {0}", BridgeMarket.Status()); e.Mobile.SendMessage("Bridge: {0}", BridgePages.Status()); + e.Mobile.SendMessage("Bridge: {0}", BridgeRuleset.Status()); break; } } diff --git a/overlay/Scripts/Custom/Bridge/BridgeConfig.cs b/overlay/Scripts/Custom/Bridge/BridgeConfig.cs index 21907ce..bd1362a 100644 --- a/overlay/Scripts/Custom/Bridge/BridgeConfig.cs +++ b/overlay/Scripts/Custom/Bridge/BridgeConfig.cs @@ -35,6 +35,25 @@ namespace Server.Custom.Bridge public static int CitySweepSeconds { get; private set; } public static int PresenceSweepSeconds { get; private set; } public static int HousingSweepSeconds { get; private set; } + public static int PointsSweepSeconds { get; private set; } + public static int MarketSweepSeconds { get; private set; } + + // ---- player-vendor market index (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §8) ---- + public static bool MarketEnabled { get; private set; } + public static int MarketSweepBatch { get; private set; } + public static int MarketMaxListings { get; private set; } + + // ---- points / loyalty leaderboards (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §7) ---- + public static bool PointsLeaderboardEnabled { get; private set; } + public static int PointsTopN { get; private set; } + public static string PointsSystems { get; private set; } + public static bool PointsProfileEnabled { get; private set; } + public static bool PointsProfileRank { get; private set; } + + // ---- shard ruleset (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §5) ---- + public static bool RulesetEnabled { get; private set; } + public static string PublicConnectAddress { get; private set; } + public static bool RulesetIncludeSchedule { get; private set; } public static string LinkUrl { get; private set; } @@ -107,6 +126,73 @@ namespace Server.Custom.Bridge if (HousingSweepSeconds < 1) HousingSweepSeconds = 1; + // Points/loyalty boards. The sweep touches every point entry on the shard, and ten of + // the ~25 systems keep a row per character ever created, so the default interval is + // deliberately slow — these are month-scale standings, not live state. + PointsSweepSeconds = Config.Get("Bridge.PointsSweepSeconds", 300); + if (PointsSweepSeconds < 1) + PointsSweepSeconds = 1; + + PointsLeaderboardEnabled = Config.Get("Bridge.PointsLeaderboardEnabled", true); + + // Board size. Bounded below at 1 because the selection indexes the Nth slot directly, + // and above at 100 because the frame is emitted per system — a large N multiplied by + // ~25 systems is how a "board" turns into a bandwidth problem. + PointsTopN = Config.Get("Bridge.PointsTopN", 10); + if (PointsTopN < 1) + PointsTopN = 1; + if (PointsTopN > 100) + PointsTopN = 100; + + // Blank (the default) means "publish whatever the shard itself shows on the loyalty + // gump", so a shard that adds a subsystem gets its board without an edit here. + PointsSystems = Config.Get("Bridge.PointsSystems", ""); + + PointsProfileEnabled = Config.Get("Bridge.PointsProfileEnabled", true); + + // Off by default, and the default is the point: a rank cannot early-exit the way a + // points lookup can — it must count every row that beats the player, in every system, + // on every profile build. See BridgeProfile.WritePoints. + PointsProfileRank = Config.Get("Bridge.PointsProfileRank", false); + + // Player-vendor market index. Unlike every other sweep, this one does NOT walk its whole + // collection per tick: MarketSweepBatch caps how many vendors are inventoried, and a + // persistent cursor round-robins through the rest, so the per-tick cost is bounded by + // the batch rather than by how many vendors the world holds. + MarketEnabled = Config.Get("Bridge.MarketEnabled", true); + + MarketSweepSeconds = Config.Get("Bridge.MarketSweepSeconds", 60); + if (MarketSweepSeconds < 1) + MarketSweepSeconds = 1; + + // Bounded below at 1 (a batch of 0 would advance the cursor nowhere and publish nothing, + // silently) and above at 500, past which the batch stops bounding anything on any + // realistic shard and the tick is a whole-world pass by another name. + MarketSweepBatch = Config.Get("Bridge.MarketSweepBatch", 25); + if (MarketSweepBatch < 1) + MarketSweepBatch = 1; + if (MarketSweepBatch > 500) + MarketSweepBatch = 500; + + // Per-vendor listing cap. BridgeJson.Parse caps INBOUND frames at 1 MB; outbound is + // uncapped and the sidecar's read_line will allocate whatever arrives, so the cap here + // is what keeps one commodity reseller with 8,000 stacked resources from emitting a + // multi-megabyte frame. Over the cap the frame carries "truncated": true and the site + // says so. + MarketMaxListings = Config.Get("Bridge.MarketMaxListings", 250); + if (MarketMaxListings < 1) + MarketMaxListings = 1; + if (MarketMaxListings > 5000) + MarketMaxListings = 5000; + + // The ruleset frame is not a sweep — it is emitted once per sidecar connect (and on + // `[bridge reload`), so it has no interval. PublicConnectAddress is the ONE connection + // detail the bridge will publish, and only because an operator typed it here for that + // purpose; Server.cfg's Address/Port are never read (see BridgeRuleset's allowlist note). + RulesetEnabled = Config.Get("Bridge.RulesetEnabled", true); + PublicConnectAddress = Config.Get("Bridge.PublicConnectAddress", ""); + RulesetIncludeSchedule = Config.Get("Bridge.RulesetIncludeSchedule", true); + LinkUrl = Config.Get("Bridge.LinkUrl", "https://yoursite/link"); TownCrierMaxLines = Config.Get("Bridge.TownCrierMaxLines", 6); diff --git a/overlay/Scripts/Custom/Bridge/BridgeMarket.cs b/overlay/Scripts/Custom/Bridge/BridgeMarket.cs new file mode 100644 index 0000000..9c2fe80 --- /dev/null +++ b/overlay/Scripts/Custom/Bridge/BridgeMarket.cs @@ -0,0 +1,591 @@ +using System; +using System.Collections.Generic; +using System.Text; + +using Server.Items; +using Server.Mobiles; +using Server.Multis; +using Server.Engines.VendorSearching; + +namespace Server.Custom.Bridge +{ + /// + /// The shard-wide player-vendor index (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §8). Every player vendor's + /// shop name, owner, location and priced inventory, published as one authoritative + /// vendor.listing frame per vendor, so the website can offer the search the in-game + /// Vendor Search gump offers — from outside the game. + /// + /// ---- Why this is a sweep and not an RPC ---- + /// + /// The obvious shape is a market.snapshot request/reply like vendor.snapshot next + /// door. It cannot work: the sidecar's rpc router correlates on the FIRST frame carrying a + /// matching reqId and resolves a single oneshot, so a chunked reply sharing one reqId would + /// deliver chunk 1 to the HTTP caller and LEAK chunks 2..N onto the broadcast feed. A + /// whole-world snapshot in one frame is not an option either — the reply timeout is 10 s and + /// 40,000 listings do not serialize in time. + /// + /// So it is a diff sweep on the broadcast stream, shaped like : + /// one frame per vendor, authoritative for that vendor, plus vendor.listing.remove when one + /// goes away. The per-account vendor.snapshot RPC is untouched; the player portal + /// keeps using it. + /// + /// ---- The two perf traps, and what this does about them ---- + /// + /// 1. **VendorSearch.GetItemName is a packet builder, not a field read.** It constructs an + /// ObjectPropertyList, calls GetProperties, serialises it and then byte-parses the + /// resulting packet — PER ITEM. Across a full pass that is a multi-hundred-millisecond + /// stall on the Core thread. It is never called here. The frame carries `itemId`, `hue`, + /// `amount`, `price`, the plain `item.Name` field (null for most items) and + /// `item.LabelNumber`; the website resolves display names against its own cliloc table, + /// exactly as char.profile.equipment already does. + /// + /// (On any modern client the call would not even work: every current client ships its + /// Cliloc.* files compressed, ServUO's bundled Ultima.StringList reads only the old plain + /// layout, so VendorSearch.StringList is null and GetItemName returns item.Name anyway. + /// The in-game gump has the same gap.) + /// + /// 2. **A full pass is unbounded in world size.** 500 vendors × 80 listings is ~40,000 item + /// reads, and the reusable public GetItems(Container, List<Item>) recurses into + /// sub-containers, so the real count runs ABOVE the top-level pack.Items a naive estimate + /// would use. So the sweep is amortized: a persistent round-robin cursor over + /// PlayerVendor.PlayerVendors advances at most MarketSweepBatch vendors per tick, which + /// makes the PER-TICK cost bounded independently of how many vendors exist. Full coverage + /// takes ceil(vendors / batch) × MarketSweepSeconds. This is the one genuinely new pattern + /// versus the other sweeps, which all walk their whole collection every tick. + /// + /// ---- Privacy ---- + /// + /// `pv.VendorSearch` is ServUO's own per-vendor opt-out and DoSearch filters on it, so a + /// player who hid their vendor in game is hidden on the website too: an opted-out vendor is + /// skipped entirely and the seen-set removal then drops it from the board. Map.Internal and + /// a null Backpack are skipped for the same reason DoSearch skips them. + /// + /// Owner is written as flat `ownerSerial`/`ownerName` — never through BridgeJson.Actor, + /// which would add `acct` and `webId`. Same argument BridgePoints makes: this is the widest- + /// audience surface the bridge has, and the site resolves serial → user from its own + /// shard_account_links mirror when staff need it. + /// + public static class BridgeMarket + { + private static Timer _timer; + + // vendor serial -> last-emitted signature. + private static readonly Dictionary _last = new Dictionary(); + + // Round-robin cursor: an INDEX into PlayerVendor.PlayerVendors, not a serial. The list is + // mutated by placement/deletion between ticks, so the cursor is a hint, not a promise — it + // is wrapped and clamped every tick, and a shifted list at worst re-visits or defers a + // vendor by one cycle. Tracking a serial instead would cost a lookup to find "where was I" + // and buy nothing: the sweep is idempotent per vendor. + private static int _cursor; + + private static long _sweeps, _emitted, _removed, _scanned, _skipped, _truncated; + + // Per-tick cost, in milliseconds. Reported by `[bridge status` because the + // whole design of this sweep is a claim about that number — the batch cap is what makes it + // independent of world size — and an operator tuning MarketSweepBatch is otherwise tuning + // blind. `_maxMs` is the one that matters: the Core thread runs this between frames, so the + // worst tick is the budget, not the average. + private static double _lastMs, _maxMs; + private static readonly System.Diagnostics.Stopwatch _clock = new System.Diagnostics.Stopwatch(); + + // Reused across ticks. The item walk is single-threaded (Core thread) and the list is + // cleared before each vendor, so one buffer serves the whole sweep — the alternative is a + // fresh List per vendor per tick, which at 25 vendors × every 60 s is pure garbage. + private static readonly List _items = new List(); + + public static void Initialize() + { + if (!BridgeConfig.Enabled) + return; + + EventSink.ServerStarted += OnServerStarted; + } + + private static void OnServerStarted() + { + BridgeLink.Connected_Core += OnConnected; + Rearm(); + } + + private static void OnConnected() + { + // A new sidecar knows nothing, so drop the diff state and start the round-robin from + // the top. The re-emit of the whole world is self-throttled by the batch window — this + // is the one place the amortized sweep pays for itself twice, because a reconnect on a + // whole-world sweep would otherwise be the biggest burst the bridge ever produces. + _last.Clear(); + _cursor = 0; + } + + /// Stops and recreates the timer from current config. Called by `[bridge reload`. + public static void Rearm() + { + Stop(); + + _timer = Timer.DelayCall( + TimeSpan.FromSeconds(BridgeConfig.MarketSweepSeconds), + TimeSpan.FromSeconds(BridgeConfig.MarketSweepSeconds), + MarketSweep); + } + + public static void Stop() + { + if (_timer != null) { _timer.Stop(); _timer = null; } + } + + /// + /// A bare (key-less) string value, or JSON null. + /// + /// takes a non-null string — it dereferences + /// value.Length immediately — and writes the `,"key":` + /// prefix itself, so neither serves a value written inside a hand-built object. Most of + /// what this frame writes is legitimately null (an item's plain Name is null for nearly + /// every item, a vendor standing in the street has no house), so this is the common path + /// rather than an edge case. + /// + private static void Text(StringBuilder sb, string value) + { + if (value == null) + sb.Append("null"); + else + BridgeJson.Escape(sb, value); + } + + public static string Status() + { + var all = PlayerVendor.PlayerVendors; + + return String.Format( + "market(enabled={0} sweeps={1} scanned={2} emitted={3} removed={4} skipped={5} truncated={6} tracked={7} vendors={8} cursor={9} batch={10} lastMs={11:F2} maxMs={12:F2})", + BridgeConfig.MarketEnabled, _sweeps, _scanned, _emitted, _removed, _skipped, + _truncated, _last.Count, all == null ? 0 : all.Count, _cursor, + BridgeConfig.MarketSweepBatch, _lastMs, _maxMs); + } + + /// Runs one sweep now. Wired into `[bridge sweepnow`. + public static void SweepOnce() + { + MarketSweep(); + } + + /// + /// One tick: at most MarketSweepBatch vendors starting at the cursor, then the + /// removal pass. + /// + /// The removal pass is the part the batching makes subtle. `_last` holds every vendor + /// seen in ANY previous tick, but this tick only visited a window — so "not in this + /// tick's seen set" does NOT mean gone. Removals are therefore decided against the + /// CURRENT vendor list (plus the opt-out/validity rules), not against the window, which + /// is a cheap pass over serials rather than a second inventory walk. + /// + private static void MarketSweep() + { + try + { + if (!BridgeConfig.MarketEnabled) + return; + + _sweeps++; + + if (!BridgeLink.Connected) + return; // nothing is listening; do not fill the queue with perishable snapshots + + _clock.Restart(); + + var all = PlayerVendor.PlayerVendors; + + if (all == null || all.Count == 0) + { + Reap(null); + return; + } + + // A live set of every serial that SHOULD be on the board right now, built as the + // window is walked plus a cheap pass over the rest. Built here rather than reusing + // a field so a throwing vendor cannot leave a half-built set behind. + var present = new HashSet(); + + var count = all.Count; + var batch = Math.Min(BridgeConfig.MarketSweepBatch, count); + + if (_cursor >= count) + _cursor = 0; + + for (int i = 0; i < count; i++) + { + var vendor = all[i]; + + if (Eligible(vendor)) + present.Add(vendor.Serial); + } + + for (int n = 0; n < batch; n++) + { + var index = (_cursor + n) % count; + var vendor = all[index]; + + if (!Eligible(vendor)) + { + _skipped++; + continue; + } + + // One bad vendor must not cost the rest of the window: the item walk touches + // arbitrary Item subclasses on a shard running modified scripts. + try + { + SweepVendor(vendor); + } + catch (Exception ex) + { + Console.WriteLine("[Bridge] market sweep threw for 0x{0:X}: {1}", + vendor.Serial.Value, ex.Message); + } + } + + _cursor = count == 0 ? 0 : (_cursor + batch) % count; + + Reap(present); + } + catch (Exception ex) + { + Console.WriteLine("[Bridge] market sweep threw: {0}", ex.Message); + } + finally + { + // In `finally` so a throwing tick still records what it cost — a sweep that blows + // the budget and then throws is exactly the one worth seeing in the status line. + if (_clock.IsRunning) + { + _clock.Stop(); + _lastMs = _clock.Elapsed.TotalMilliseconds; + if (_lastMs > _maxMs) + _maxMs = _lastMs; + + WarnIfSlow(); + } + } + } + + /// + /// Per-tick budget, milliseconds. The batch cap exists to hold a tick under this + /// regardless of world size, so exceeding it means MarketSweepBatch is too large for + /// this shard's shops — the one thing an operator needs told, and the one thing + /// `[bridge status` cannot tell them unprompted. Generous: a tick is off the frame + /// budget, and the alternative to a rare 50 ms tick is a permanently stale market. + /// + private const double SlowTickMs = 50.0; + + // At most one warning a minute. A shard whose batch is genuinely too big would otherwise + // print every MarketSweepSeconds forever, and a log nobody can read is a log nobody reads. + private static DateTime _lastWarn = DateTime.MinValue; + + private static void WarnIfSlow() + { + if (_lastMs <= SlowTickMs) + return; + + var now = DateTime.UtcNow; + + if (now - _lastWarn < TimeSpan.FromMinutes(1)) + return; + + _lastWarn = now; + + Console.WriteLine( + // ASCII only. The ServUO console writes in the OS code page, so an em dash here + // renders as "???" in the log an operator would paste into an issue. + "[Bridge] market sweep took {0:F1} ms (budget {1:F0} ms) - lower Bridge.MarketSweepBatch (now {2}) if this persists", + _lastMs, SlowTickMs, BridgeConfig.MarketSweepBatch); + } + + /// + /// The same filter DoSearch applies, so the website's index is the in-game index. + /// VendorSearch is the player's own opt-out toggle and is honoured first. + /// + private static bool Eligible(PlayerVendor vendor) + { + return vendor != null + && !vendor.Deleted + && vendor.VendorSearch + && vendor.Map != null + && vendor.Map != Map.Internal + && vendor.Backpack != null; + } + + /// + /// Drops from the board every tracked vendor that is no longer eligible. + /// null means "there are no vendors at all", which clears it. + /// + private static void Reap(HashSet present) + { + if (_last.Count == 0) + return; + + List gone = null; + + foreach (var serial in _last.Keys) + { + if (present != null && present.Contains(serial)) + continue; + + if (gone == null) + gone = new List(); + + gone.Add(serial); + } + + if (gone == null) + return; + + for (int i = 0; i < gone.Count; i++) + { + _last.Remove(gone[i]); + BridgeLink.Emit(BridgeJson.Begin("vendor.listing.remove").Ser("serial", gone[i]).End()); + _removed++; + } + } + + private static void SweepVendor(PlayerVendor vendor) + { + _scanned++; + + CollectItems(vendor); + + var sig = Signature(vendor); + + string prior; + if (_last.TryGetValue(vendor.Serial, out prior) && prior == sig) + return; // nothing about this shop changed since it was last published + + _last[vendor.Serial] = sig; + BridgeLink.Emit(WriteVendor(vendor)); + _emitted++; + } + + /// + /// Every sellable item on one vendor, into the shared buffer. + /// + /// Mirrors VendorSearch's own private GetItems(PlayerVendor): the vendor's own movable + /// equipment (minus the backpack itself and hair layers, which are not merchandise) + /// followed by a recursive walk of the backpack. The recursion uses the PUBLIC + /// GetItems(Container, List<Item>) rather than a hand-rolled one so that ServUO's + /// rule about which containers are sold whole (quivers, seed boxes, jewelry boxes, …) + /// stays ServUO's to define — the predicate that decides it is private, and a copy here + /// would silently diverge the first time that list changes. + /// + private static void CollectItems(PlayerVendor vendor) + { + _items.Clear(); + + var own = vendor.Items; + + if (own != null) + { + for (int i = 0; i < own.Count; i++) + { + var item = own[i]; + + if (item == null || !item.Movable || item == vendor.Backpack) + continue; + + if (item.Layer == Layer.Hair || item.Layer == Layer.FacialHair) + continue; + + _items.Add(item); + } + } + + if (vendor.Backpack != null) + VendorSearch.GetItems(vendor.Backpack, _items); + } + + /// + /// A listing's price, and whether it was priced by an enclosing container. + /// + /// ServUO prices a container as a unit: an item inside a priced bag has no VendorItem of + /// its own and inherits the bag's price, which DoSearch surfaces as `isChild`. Reproduced + /// exactly, because a website that priced every item in a 40k bag at 40k would be lying + /// about the shard. + /// + private static int PriceOf(PlayerVendor vendor, Item item, out bool child) + { + child = false; + + var vi = vendor.GetVendorItem(item); + + if (vi != null) + return vi.Price; + + var parent = item.Parent as Container; + + while (parent != null) + { + vi = vendor.GetVendorItem(parent); + + if (vi != null) + { + child = true; + return vi.Price; + } + + parent = parent.Parent as Container; + } + + return 0; + } + + /// + /// The diff key. Location, shop name and owner are in it because they move a vendor's + /// row on the site; every listing's serial, price and amount are in it because those are + /// what a shopper searches on. + /// + /// Built over the SAME buffer the frame is written from, in the same order, so a + /// signature match really does mean an identical frame — a cheaper hash (count + a sum + /// of serial^price, as §8.3 first proposed) collides on the common case of two items + /// swapping prices, which is exactly what re-pricing a shop looks like. + /// + private static string Signature(PlayerVendor vendor) + { + var sb = new StringBuilder(256); + + sb.Append(vendor.ShopName ?? "").Append('|'); + sb.Append(vendor.Owner == null ? 0 : vendor.Owner.Serial.Value).Append('|'); + sb.Append(vendor.Map == null ? "" : vendor.Map.Name).Append('|'); + sb.Append(vendor.X).Append(',').Append(vendor.Y).Append('|'); + + var limit = Math.Min(_items.Count, BridgeConfig.MarketMaxListings); + + sb.Append(_items.Count).Append('|'); + + for (int i = 0; i < limit; i++) + { + var item = _items[i]; + + if (item == null || item.Deleted) + continue; + + bool child; + var price = PriceOf(vendor, item, out child); + + if (price <= 0) + continue; + + sb.Append(item.Serial.Value.ToString("X")).Append(':') + .Append(price).Append(':') + .Append(item.Amount).Append(';'); + } + + return sb.ToString(); + } + + /// + /// One vendor frame — authoritative for that vendor, so the website replaces its whole + /// listing set from it rather than merging. + /// + /// `location` is one nested object rather than flat map/x/y/region because it is ONE + /// admin-configurable field on the site (`market.location`): the visibility projection + /// matches literal JSON keys, so a nested object is what lets a single rule hide a + /// vendor's whereabouts on both the live frame and the stored read model. Flat keys + /// would need five rules that could drift apart. + /// + /// `count` is the number of listings PUBLISHED, and `truncated` says the shop holds + /// more. A shop over the cap is a real thing (commodity resellers run thousands of + /// stacks) and the site says so rather than quietly showing a partial shop as complete. + /// + private static string WriteVendor(PlayerVendor vendor) + { + var sb = BridgeJson.Begin("vendor.listing") + .Ser("serial", vendor.Serial) + .Str("shopName", vendor.ShopName); + + var owner = vendor.Owner; + + if (owner != null) + { + sb.Ser("ownerSerial", owner.Serial); + sb.Str("ownerName", owner.Name); + } + + sb.Append(",\"location\":{\"map\":"); + Text(sb, vendor.Map == null ? null : vendor.Map.Name); + sb.Append(",\"x\":").Append(vendor.X); + sb.Append(",\"y\":").Append(vendor.Y); + sb.Append(",\"z\":").Append(vendor.Z); + + var region = vendor.Region; + sb.Append(",\"region\":"); + Text(sb, region == null ? null : region.Name); + + // The house name is the sign's, which is what a player would be told to look for + // ("Bob's Villa"), not the house type. Null for a vendor standing outside one. + var house = vendor.House; + var sign = house == null ? null : house.Sign; + sb.Append(",\"house\":"); + Text(sb, sign == null ? null : sign.GetName()); + + sb.Append('}'); + + var max = BridgeConfig.MarketMaxListings; + var published = 0; + var considered = 0; + + var items = new StringBuilder(512); + + for (int i = 0; i < _items.Count; i++) + { + var item = _items[i]; + + if (item == null || item.Deleted) + continue; + + bool child; + var price = PriceOf(vendor, item, out child); + + // Unpriced items are inventory, not listings — DoSearch drops them the same way. + if (price <= 0) + continue; + + considered++; + + if (published >= max) + continue; + + if (published > 0) + items.Append(','); + + items.Append("{\"serial\":\"0x").Append(item.Serial.Value.ToString("X")).Append('"'); + items.Append(",\"itemId\":").Append(item.ItemID); + items.Append(",\"hue\":").Append(item.Hue); + items.Append(",\"amount\":").Append(item.Amount); + items.Append(",\"price\":").Append(price); + + // The PLAIN Name field, which is null for most items — never GetItemName, which + // builds and parses a property packet per item. LabelNumber is the cliloc the + // website resolves against its own table. + items.Append(",\"name\":"); + Text(items, item.Name); + items.Append(",\"cliloc\":").Append(item.LabelNumber); + + if (child) + items.Append(",\"child\":true"); + + items.Append('}'); + + published++; + } + + sb.Num("count", published); + sb.Num("total", considered); + sb.Bool("truncated", considered > published); + + if (considered > published) + _truncated++; + + sb.Append(",\"items\":[").Append(items).Append(']'); + + return sb.End(); + } + } +} diff --git a/overlay/Scripts/Custom/Bridge/BridgePoints.cs b/overlay/Scripts/Custom/Bridge/BridgePoints.cs new file mode 100644 index 0000000..2a85c9d --- /dev/null +++ b/overlay/Scripts/Custom/Bridge/BridgePoints.cs @@ -0,0 +1,404 @@ +using System; +using System.Collections.Generic; +using System.Text; + +using Server.Engines.Points; + +namespace Server.Custom.Bridge +{ + /// + /// Points / loyalty leaderboards (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §7). ServUO carries ~25 separate point + /// currencies (Queen's Loyalty, Void Pool, Casino, Clean Up Britannia, the nine city + /// loyalties, Blackthorn, the Doom/Khaldun/Kotl treasure systems, …), every one of them a + /// standing a player accumulates over months — and none of them has ever been visible + /// anywhere but an in-game gump. This is the diff sweep that publishes them as boards. + /// + /// Shaped like : ServerStarted arms a timer, a sidecar connect + /// clears the diff state so a fresh sidecar gets every board, and each pass emits only the + /// systems whose top N actually moved. One frame per system (~600 B) rather than one 12 KB + /// frame, matching champ.update / guild.update. + /// + /// **There is no `points.remove`.** The set of systems is fixed at Configure() time by + /// PointsSystem.Configure — a system cannot disappear at runtime — which is the same + /// argument city.update already makes for cities. + /// + /// ---- The perf trap, and why the selection looks like this ---- + /// + /// `PlayerTable` is a plain List<PointsEntry>, and QueensLoyalty has AutoAdd = true, so it + /// holds an entry for every PlayerMobile that has ever logged in — zero-point rows included. + /// The obvious `.OrderByDescending(e => e.Points).Take(N)` is a full sort PER SYSTEM: at + /// 20,000 historical characters that is ~25 sorts and ~7.5 M comparisons on the Core thread, + /// tens of milliseconds, which BRIDGE_PLUGIN_PLAN.md §1 measured as the second thing in the + /// whole bridge capable of blowing a frame budget (bulk profile generation being the first). + /// + /// So: a single pass per system into a fixed N-element array kept sorted by insertion. + /// O(n·N) with tiny constants, one allocation for the whole sweep, and the common case is a + /// single comparison against the running Nth place before the row is rejected. ~500 k cheap + /// iterations per pass at the default 300 s interval. + /// + public static class BridgePoints + { + private static Timer _timer; + + // PointsType name -> last-emitted signature. + private static readonly Dictionary _last = + new Dictionary(StringComparer.Ordinal); + + private static long _sweeps, _emitted; + + // Reused across systems and across sweeps: the selection is single-threaded (Core thread) + // and fully overwritten each time, so there is nothing to allocate per pass. + private static PointsEntry[] _top = new PointsEntry[0]; + + public static void Initialize() + { + if (!BridgeConfig.Enabled) + return; + + EventSink.ServerStarted += OnServerStarted; + } + + private static void OnServerStarted() + { + BridgeLink.Connected_Core += OnConnected; + Rearm(); + } + + private static void OnConnected() + { + // A new sidecar knows nothing; drop the diff state so the next pass re-emits every board. + _last.Clear(); + } + + /// Stops and recreates the timer from current config. Called by `[bridge reload`. + public static void Rearm() + { + Stop(); + + _timer = Timer.DelayCall( + TimeSpan.FromSeconds(BridgeConfig.PointsSweepSeconds), + TimeSpan.FromSeconds(BridgeConfig.PointsSweepSeconds), + PointsSweep); + } + + public static void Stop() + { + if (_timer != null) { _timer.Stop(); _timer = null; } + } + + public static string Status() + { + return String.Format("points(enabled={0} sweeps={1} emitted={2} tracked={3} topN={4})", + BridgeConfig.PointsLeaderboardEnabled, _sweeps, _emitted, _last.Count, + BridgeConfig.PointsTopN); + } + + /// Runs one sweep now. Wired into `[bridge sweepnow`. + public static void SweepOnce() + { + PointsSweep(); + } + + private static void PointsSweep() + { + try + { + if (!BridgeConfig.PointsLeaderboardEnabled) + return; + + _sweeps++; + + if (!BridgeLink.Connected) + return; // nothing is listening; do not fill the queue with perishable snapshots + + // Systems is a mutable static populated by ~25 separate subsystem constructors in + // PointsSystem.Configure(). It is null before that runs and could in principle hold + // a null element, so neither is assumed. + var systems = PointsSystem.Systems; + + if (systems == null) + return; + + var selected = SelectedSystems(); + + var n = BridgeConfig.PointsTopN; + if (_top.Length != n) + _top = new PointsEntry[n]; + + for (int i = 0; i < systems.Count; i++) + { + var sys = systems[i]; + + if (sys == null) + continue; + + // One bad system must not cost the rest of the sweep: Name/MaxPoints are + // abstract members implemented by 25 unrelated subsystems, any of which could + // throw on a shard running modified scripts. + try + { + SweepSystem(sys, selected); + } + catch (Exception ex) + { + Console.WriteLine("[Bridge] points sweep threw for {0}: {1}", + sys.Loyalty, ex.Message); + } + } + } + catch (Exception ex) + { + Console.WriteLine("[Bridge] points sweep threw: {0}", ex.Message); + } + } + + private static void SweepSystem(PointsSystem sys, HashSet selected) + { + var key = sys.Loyalty.ToString(); + + if (!IsPublished(sys, key, selected)) + return; + + int ranked; + var count = SelectTop(sys, out ranked); + + var sig = Signature(count, ranked); + + string prior; + if (_last.TryGetValue(key, out prior) && prior == sig) + return; // top N and participant count both unchanged since last emit + + _last[key] = sig; + BridgeLink.Emit(WriteBoard(sys, key, count, ranked)); + _emitted++; + } + + /// + /// Which systems are published. The default is the shard's OWN answer to "is this + /// player-facing?" — ShowOnLoyaltyGump, the flag that decides whether a system appears + /// on the in-game loyalty gump — rather than a list invented here that would drift from + /// the server every time a subsystem is added. `Bridge.cfg PointsSystems=` overrides it + /// with an explicit comma-separated list of PointsType names. + /// + private static bool IsPublished(PointsSystem sys, string key, HashSet selected) + { + if (selected != null) + return selected.Contains(key); + + return sys.ShowOnLoyaltyGump; + } + + // Parsed form of BridgeConfig.PointsSystems, rebuilt when the raw string changes so + // `[bridge reload` picks up an edit without a restart. null == "no override, use + // ShowOnLoyaltyGump". + private static string _selectedRaw; + private static HashSet _selected; + + private static HashSet SelectedSystems() + { + var raw = BridgeConfig.PointsSystems ?? ""; + + if (raw == _selectedRaw) + return _selected; + + _selectedRaw = raw; + _selected = null; + + if (raw.Trim().Length == 0) + return null; + + var set = new HashSet(StringComparer.Ordinal); + + foreach (var part in raw.Split(',')) + { + var name = part.Trim(); + + if (name.Length == 0) + continue; + + // Resolve through the enum so a typo is reported loudly rather than silently + // publishing one board fewer than the operator asked for. + PointsType parsed; + if (Enum.TryParse(name, true, out parsed) && Enum.IsDefined(typeof(PointsType), parsed)) + set.Add(parsed.ToString()); + else + Console.WriteLine("[Bridge] unknown PointsSystems entry '{0}', ignoring", name); + } + + _selected = set; + return _selected; + } + + /// + /// Single pass over one system's PlayerTable, keeping the best _top.Length entries + /// in descending order. Returns how many slots were filled; + /// receives the number of players actually holding points. + /// + /// Ties do not displace (the shift test is strict, and the reject test is inclusive), so + /// an unchanged table produces an unchanged board — which is what makes the diff + /// signature meaningful rather than a source of spurious re-emits. + /// + private static int SelectTop(PointsSystem sys, out int ranked) + { + ranked = 0; + + var table = sys.PlayerTable; + var top = _top; + + if (table == null || top.Length == 0) + return 0; + + var count = 0; + + for (int i = 0; i < table.Count; i++) + { + var entry = table[i]; + + if (entry == null) + continue; + + var player = entry.Player; + + // A deleted character keeps its row until the next save/load cycle, and AutoAdd + // systems are mostly zero-point rows. Neither belongs on a leaderboard. + if (player == null || player.Deleted || entry.Points <= 0) + continue; + + ranked++; + + var points = entry.Points; + + // The common case for a big table: worse than the running Nth place, one compare. + if (count == top.Length && points <= top[count - 1].Points) + continue; + + var pos = count < top.Length ? count : top.Length - 1; + + while (pos > 0 && top[pos - 1].Points < points) + { + top[pos] = top[pos - 1]; + pos--; + } + + top[pos] = entry; + + if (count < top.Length) + count++; + } + + return count; + } + + /// + /// A system's point ceiling as a whole number, or **0 meaning "uncapped"**. + /// + /// `MaxPoints` is a double, and ServUO's idiom for "no cap" is `double.MaxValue` + /// (DespiseCrystals, ShameCrystals and VoidPool all do this). A plain `(long)` cast of + /// that is an UNCHECKED conversion — it does not throw, it produces `long.MinValue` — + /// which is exactly what the first sweep against a real shard published: + /// `"maxPoints": -9223372036854775808`. Anything not representable as a positive long + /// therefore becomes 0, which the website already renders as "no maximum". + /// + internal static long Cap(double value) + { + // NaN first: every comparison against NaN is false, so it would otherwise fall through + // to the same unchecked cast. + if (Double.IsNaN(value) || value <= 0 || value >= 9.2233720368547758E18) + return 0; + + return (long)value; + } + + /// + /// A score as a whole number. Same unchecked-cast hazard as , but the + /// saturating direction is the opposite: an implausibly large score is still a large + /// score, so it clamps to long.MaxValue rather than collapsing to 0. + /// + internal static long Score(double value) + { + if (Double.IsNaN(value) || value <= 0) + return 0; + + if (value >= 9.2233720368547758E18) + return Int64.MaxValue; + + return (long)value; + } + + /// + /// The diff key: every published serial and its whole-point score, plus the participant + /// count. Points are compared exactly as they are emitted, so a fractional award that + /// does not move the displayed number does not cost a frame either. + /// + private static string Signature(int count, int ranked) + { + var sb = new StringBuilder(64); + + sb.Append(ranked).Append('|'); + + for (int i = 0; i < count; i++) + { + var entry = _top[i]; + sb.Append(entry.Player.Serial.Value.ToString("X")) + .Append(':') + .Append(Score(entry.Points)) + .Append(';'); + } + + return sb.ToString(); + } + + /// + /// One board frame. + /// + /// `nameString` AND `nameNumber` are both emitted because Name is a TextDefinition, which + /// may carry either a literal or a cliloc id — the same contract titles.reward already + /// documents at BridgeProfile.cs:107-110. Resolving clilocs is the website's job. + /// + /// **Entries are written inline as {serial, name} — never through BridgeJson.Actor.** + /// That is deliberate even though the website can now reveal fields by audience rung: + /// Actor would add `acct` and `webId`, and neither is needed here, because the site + /// resolves serial → user from its own shard_account_links mirror for staff views. A + /// board is the widest-audience surface the bridge has; the account name of every ranked + /// player has no business crossing the wire to reach it. + /// + private static string WriteBoard(PointsSystem sys, string key, int count, int ranked) + { + var name = sys.Name; + + var sb = BridgeJson.Begin("points.board") + .Str("system", key) + .Str("nameString", name == null ? null : name.String) + .Num("nameNumber", name == null ? 0 : name.Number) + .Num("maxPoints", Cap(sys.MaxPoints)) + .Bool("showOnGump", sys.ShowOnLoyaltyGump) + // Players actually HOLDING points, not PlayerTable.Count: an AutoAdd system has a + // zero-point row for every character that ever logged in, so the raw count would + // report the shard's whole character census as this system's participants. + .Num("players", ranked); + + sb.Append(",\"top\":["); + + for (int i = 0; i < count; i++) + { + var entry = _top[i]; + + if (i > 0) + sb.Append(','); + + sb.Append("{\"rank\":").Append(i + 1); + sb.Append(",\"serial\":\"0x").Append(entry.Player.Serial.Value.ToString("X")).Append('"'); + sb.Append(",\"name\":"); + BridgeJson.Escape(sb, entry.Player.Name ?? ""); + // Whole points: every one of these systems awards and displays integers in game, + // and a board that renders 29500.00000000001 would be a bug report. + sb.Append(",\"points\":").Append(Score(entry.Points)); + sb.Append('}'); + } + + sb.Append(']'); + + return sb.End(); + } + } +} diff --git a/overlay/Scripts/Custom/Bridge/BridgeProfile.cs b/overlay/Scripts/Custom/Bridge/BridgeProfile.cs index dd3a30b..b69d7c3 100644 --- a/overlay/Scripts/Custom/Bridge/BridgeProfile.cs +++ b/overlay/Scripts/Custom/Bridge/BridgeProfile.cs @@ -2,6 +2,7 @@ using System; using System.Text; using Server.Accounting; +using Server.Engines.Points; using Server.Items; using Server.Mobiles; @@ -99,6 +100,7 @@ namespace Server.Custom.Bridge sb.Append(']'); WriteTitles(sb, m); + WritePoints(sb, m); return sb.End(); } @@ -147,6 +149,147 @@ namespace Server.Custom.Bridge sb.Append("]}"); } + /// + /// The point/loyalty standings this character holds (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §7.3). Read-model + /// enrichment on an existing kind, exactly like — there is no + /// request kind for "one character's points", because the profile is already the place + /// the website asks for everything about one character. + /// + /// Systems with no entry, or an entry at zero, are omitted: ten of the ~25 systems have + /// AutoAdd = true and therefore hold a zero-point row for every character that has ever + /// logged in, so emitting them all would be ~25 lines of noise on every sheet. + /// + /// **Never call PointsSystem.GetEntry / GetPoints here.** Both look benign and both + /// MUTATE THE WORLD: `GetEntry(from, create: false)` still calls AddEntry when the system + /// has AutoAdd (PointsSystem.cs:207), which appends a row to PlayerTable and fires + /// OnPlayerAdded. A read model that used them would silently grow the points save file by + /// up to ten rows every time anyone viewed a character sheet. Hence the manual scan. + /// + /// Cost: one early-exiting pass over each published system's PlayerTable. The AutoAdd + /// tables are census-sized, so this is the dominant term in the profile — roughly 10 × n + /// comparisons, against the ~0.069 ms/2.4 KB the rest of the profile measures at. That is + /// acceptable because profiles are built on demand at human rates and never in a sweep; + /// PointsProfileEnabled turns it off for a shard where it isn't. + /// + /// **Deliberately no `rank`.** Rank cannot early-exit — it must count every row that + /// beats the player, in every system, every time — and the website can derive it from + /// the points.board frame for anyone who is actually on a board. See PointsProfileRank. + /// + private static void WritePoints(StringBuilder sb, PlayerMobile m) + { + if (!BridgeConfig.PointsProfileEnabled) + return; + + sb.Append(",\"points\":["); + + try + { + var systems = PointsSystem.Systems; + + if (systems != null) + { + bool first = true; + + for (int i = 0; i < systems.Count; i++) + { + var sys = systems[i]; + + if (sys == null || !sys.ShowOnLoyaltyGump) + continue; + + var points = LookupPoints(sys, m); + + if (points <= 0) + continue; + + if (!first) sb.Append(','); + first = false; + + var name = sys.Name; + + sb.Append("{\"system\":\"").Append(sys.Loyalty).Append('"'); + sb.Append(",\"nameString\":"); + if (name == null || name.String == null) + sb.Append("null"); + else + BridgeJson.Escape(sb, name.String); + sb.Append(",\"nameNumber\":").Append(name == null ? 0 : name.Number); + sb.Append(",\"points\":").Append(BridgePoints.Score(points)); + sb.Append(",\"maxPoints\":").Append(BridgePoints.Cap(sys.MaxPoints)); + + // Off by default. The field is absent rather than null when disabled, so a + // consumer can tell "this shard does not compute rank" from "unranked". + if (BridgeConfig.PointsProfileRank) + sb.Append(",\"rank\":").Append(RankOf(sys, points)); + + sb.Append('}'); + } + } + } + catch (Exception ex) + { + // A profile is worth more than its points block; never fail the sheet over one. + Console.WriteLine("[Bridge] profile points threw: {0}", ex.Message); + } + + sb.Append(']'); + } + + /// + /// This character's score in one system, or 0 if it has no entry. A hand-rolled scan + /// rather than GetEntry/GetPoints for the mutation reason above; it stops at the match, + /// which the rank computation could not. + /// + private static double LookupPoints(PointsSystem sys, PlayerMobile m) + { + var table = sys.PlayerTable; + + if (table == null) + return 0; + + for (int i = 0; i < table.Count; i++) + { + var entry = table[i]; + + if (entry != null && entry.Player == m) + return entry.Points; + } + + return 0; + } + + /// + /// 1-based standing in one system: how many live characters hold strictly more points, + /// plus one. Ties share a rank, which is what a player expects to see. + /// + /// Only reachable with PointsProfileRank=true, and off by default for the reason stated + /// in : unlike the points lookup, this visits every row of the + /// table every time, so it turns a bounded early-exiting scan into a guaranteed full one + /// per published system per profile. + /// + private static int RankOf(PointsSystem sys, double points) + { + var table = sys.PlayerTable; + + if (table == null) + return 1; + + var better = 0; + + for (int i = 0; i < table.Count; i++) + { + var entry = table[i]; + + if (entry == null || entry.Player == null || entry.Player.Deleted) + continue; + + if (entry.Points > points) + better++; + } + + return better + 1; + } + private static bool IsGearLayer(Layer layer) { switch (layer) diff --git a/overlay/Scripts/Custom/Bridge/BridgeRuleset.cs b/overlay/Scripts/Custom/Bridge/BridgeRuleset.cs new file mode 100644 index 0000000..76addc0 --- /dev/null +++ b/overlay/Scripts/Custom/Bridge/BridgeRuleset.cs @@ -0,0 +1,355 @@ +using System; +using System.Text; + +using Server.Engines.CityLoyalty; +using Server.Engines.VvV; +using Server.Multis; + +namespace Server.Custom.Bridge +{ + /// + /// The shard ruleset (https://gitea.whitlocktech.com/RunicGateway/docs/src/branch/main/link/v3.md §5). One `world.ruleset` frame describing how + /// this shard is actually configured: expansion, which systems are on, skill/stat caps, house + /// and account limits, champion scroll rules, and the save/restart schedule. It is what turns + /// the website's "Rules" page from hand-maintained prose into something that cannot drift from + /// the server. + /// + /// Modelled on , NOT on the diff sweeps: the ruleset changes + /// only when an operator edits Config/*.cfg and restarts (or runs `[bridge reload`), so there is + /// nothing to poll. It subscribes Connected_Core so a sidecar that comes up second still learns + /// the ruleset, exactly as server.hello does. + /// + /// **The one hard rule: this is an explicit allowlist of Config.Get calls.** Never enumerate + /// Config.Entries (Server/Config.cs) — that would sweep in every key on the server, secrets + /// included. Files deliberately never read here, in addition to anything not named below: + /// + /// Server.cfg — Address / Listen / Port. Only Bridge.PublicConnectAddress is published, + /// and only because an operator typed it there for exactly this purpose. + /// Staff.cfg — staff account names. + /// Email.cfg — SMTP credentials. + /// DataPath.cfg — filesystem layout. + /// Bridge.cfg — the sidecar host/port and our own caps. + /// Compiler.cfg — build flags. + /// Reports.cfg — report upload credentials. + /// Client.cfg — client-version enforcement (not player-facing rules). + /// + /// `rev` is an FNV-1a hash of the emitted body, so a reconnect that carries an unchanged ruleset + /// is a no-op site-side. String.GetHashCode() is deliberately NOT used: it is randomized per + /// process on modern .NET, so it would change on every shard restart and defeat the whole point. + /// + public static class BridgeRuleset + { + private static long _emitted; + private static string _rev = ""; + private static int _bytes; + + public static void Initialize() + { + if (!BridgeConfig.Enabled) + return; + + BridgeLink.Connected_Core += Emit; + } + + public static string Status() + { + return String.Format("ruleset(enabled={0} emitted={1} rev={2} bytes={3})", + BridgeConfig.RulesetEnabled, _emitted, _rev.Length == 0 ? "-" : _rev, _bytes); + } + + /// + /// Core thread. Builds and queues one `world.ruleset` frame. Called on every sidecar + /// connect and by `[bridge reload` (an operator who just edited a .cfg wants to see the + /// change on the site without restarting the shard). + /// + public static void Emit() + { + if (!BridgeConfig.RulesetEnabled) + return; + + try + { + var body = BuildBody(); + + _rev = Fnv1a(body); + _bytes = body.Length; + _emitted++; + + // rev goes first so a reader can short-circuit on an unchanged frame before parsing + // the rest of it. + BridgeLink.Emit(BridgeJson.Begin("world.ruleset") + .Str("rev", _rev) + .Append(body) + .End()); + } + catch (Exception ex) + { + Console.WriteLine("[Bridge] ruleset emit threw: {0}", ex.Message); + } + } + + /// + /// The allowlist. Every block is optional and omitted when its system is off, so a shard + /// that does not run (say) VvV publishes no `vvv` block rather than a block of zeroes. + /// + private static string BuildBody() + { + var sb = new StringBuilder(2048); + + sb.Str("shard", Server.Misc.ServerList.ServerName); + sb.Str("expansion", Core.Expansion.ToString()); + + // The ONLY thing published from a connection-address setting, and only because the + // operator put it in Bridge.cfg specifically to be shown. Server.cfg is never read. + var connect = BridgeConfig.PublicConnectAddress; + if (!String.IsNullOrEmpty(connect)) + sb.Str("connect", connect); + + WriteSystems(sb); + WriteCaps(sb); + + sb.Append(",\"housing\":{\"accountHouseLimit\":") + .Append(BaseHouse.AccountHouseLimit).Append('}'); + + WriteAccounts(sb); + WriteVetRewards(sb); + WriteLoot(sb); + WriteVendors(sb); + WriteChampions(sb); + WriteTreasureMaps(sb); + WriteVvV(sb); + WriteStore(sb); + + if (BridgeConfig.RulesetIncludeSchedule) + WriteSchedule(sb); + + return sb.ToString(); + } + + /// + /// Which optional systems this shard runs. Read from each system's own static rather than + /// re-parsing its .cfg, so a system that derives its state (Factions is on exactly when VvV + /// is off — Services/Factions/Core/Faction.cs) is reported the way the server actually sees + /// it. This block subsumes the `world.systems` capability frame PROTOCOL_2.md §10.4 + /// sketched but never implemented. + /// + private static void WriteSystems(StringBuilder sb) + { + sb.Append(",\"systems\":{"); + sb.Append("\"cityLoyalty\":").Append(Json(CityLoyaltySystem.Enabled)); + sb.Append(",\"vvv\":").Append(Json(ViceVsVirtueSystem.Enabled)); + sb.Append(",\"factions\":").Append(Json(Server.Factions.Settings.Enabled)); + sb.Append(",\"siege\":").Append(Json(Siege.SiegeShard)); + sb.Append(",\"chat\":").Append(Json(Config.Get("Chat.Enabled", true))); + sb.Append(",\"store\":").Append(Json(Config.Get("Store.Enabled", true))); + sb.Append(",\"dailyRares\":").Append(Json(Config.Get("DailyRares.Enabled", true))); + sb.Append(",\"honesty\":").Append(Json(Config.Get("Honesty.Enabled", true))); + sb.Append(",\"shadowguard\":").Append(Json(Core.TOL)); + sb.Append(",\"treasureMaps\":").Append(Json(Config.Get("TreasureMaps.Enabled", true))); + sb.Append(",\"vetRewards\":").Append(Json(Config.Get("VetRewards.Enabled", true))); + sb.Append(",\"testCenter\":").Append(Json(Config.Get("TestCenter.Enabled", false))); + sb.Append('}'); + } + + /// + /// Skill and stat caps — the single most-asked "what are the rules here?" question, and the + /// one most often wrong on a hand-written page. SkillCap is in tenths (1000 = 100.0). + /// + private static void WriteCaps(StringBuilder sb) + { + sb.Append(",\"caps\":{"); + sb.Append("\"skill\":").Append(Config.Get("PlayerCaps.SkillCap", 1000)); + sb.Append(",\"totalSkill\":").Append(Config.Get("PlayerCaps.TotalSkillCap", 7000)); + sb.Append(",\"stat\":").Append(Config.Get("PlayerCaps.TotalStatCap", 225)); + sb.Append(",\"str\":").Append(Config.Get("PlayerCaps.StrCap", 125)); + sb.Append(",\"dex\":").Append(Config.Get("PlayerCaps.DexCap", 125)); + sb.Append(",\"int\":").Append(Config.Get("PlayerCaps.IntCap", 125)); + sb.Append(",\"strMax\":").Append(Config.Get("PlayerCaps.StrMaxCap", 150)); + sb.Append(",\"dexMax\":").Append(Config.Get("PlayerCaps.DexMaxCap", 150)); + sb.Append(",\"intMax\":").Append(Config.Get("PlayerCaps.IntMaxCap", 150)); + sb.Append('}'); + } + + /// + /// Account limits. `autoCreate` is the in-game first-login auto-create switch, which pairs + /// with the bridge's own SignupMode (BridgeConfig.WarnOnSignupMismatch) — publishing it + /// lets the site's signup page tell a visitor the truth about how to get an account. + /// Character slots come from Siege.cfg, which is where ServUO keeps them regardless of + /// whether the shard is actually Siege. + /// + private static void WriteAccounts(StringBuilder sb) + { + sb.Append(",\"accounts\":{"); + sb.Append("\"perIp\":").Append(Config.Get("Accounts.AccountsPerIp", 1)); + sb.Append(",\"charSlots\":").Append(Siege.CharacterSlots); + sb.Append(",\"autoCreate\":").Append(Json(Config.Get("Accounts.AutoCreateAccounts", true))); + sb.Append('}'); + } + + private static void WriteVetRewards(StringBuilder sb) + { + var enabled = Config.Get("VetRewards.Enabled", true); + + sb.Append(",\"vetRewards\":{\"enabled\":").Append(Json(enabled)); + + if (enabled) + { + var interval = Config.Get("VetRewards.RewardInterval", TimeSpan.FromDays(30.0)); + sb.Append(",\"rewardIntervalDays\":").Append((int)interval.TotalDays); + } + + sb.Append('}'); + } + + /// The Felucca risk-vs-reward numbers — the reason players choose a facet. + private static void WriteLoot(StringBuilder sb) + { + sb.Append(",\"loot\":{"); + sb.Append("\"feluccaLuckBonus\":").Append(Config.Get("Loot.FeluccaLuckBonus", 0)); + sb.Append(",\"feluccaBudgetBonus\":").Append(Config.Get("Loot.FeluccaBudgetBonus", 0)); + sb.Append(",\"feluccaMaxProps\":").Append(Config.Get("Loot.MaxProps", 5)); + sb.Append('}'); + } + + private static void WriteVendors(StringBuilder sb) + { + sb.Append(",\"vendors\":{"); + sb.Append("\"restockDelayMinutes\":").Append(Config.Get("Vendors.RestockDelay", 60)); + sb.Append(",\"maxSell\":").Append(Config.Get("Vendors.MaxSell", 500)); + sb.Append(",\"economyStockAmount\":").Append(Config.Get("Vendors.EconomyStockAmount", 500)); + sb.Append('}'); + } + + /// + /// Champion spawn rewards. `rankThresholds` is the red-skull count at which each rank is + /// reached, which is what a player actually wants to know before committing to a spawn. + /// + private static void WriteChampions(StringBuilder sb) + { + if (!Config.Get("Champions.Enabled", true)) + return; + + sb.Append(",\"champions\":{"); + sb.Append("\"powerScrolls\":").Append(Config.Get("Champions.PowerScrolls", 6)); + sb.Append(",\"statScrolls\":").Append(Config.Get("Champions.StatScrolls", 16)); + sb.Append(",\"scrollChance\":").Append(Json(Config.Get("Champions.ScrollChance", 0.1))); + sb.Append(",\"transcendenceChance\":") + .Append(Json(Config.Get("Champions.TranscendenceChance", 50.0))); + sb.Append(",\"rankThresholds\":[") + .Append(Config.Get("Champions.Rank2RedSkulls", 5)).Append(',') + .Append(Config.Get("Champions.Rank3RedSkulls", 10)).Append(',') + .Append(Config.Get("Champions.Rank4RedSkulls", 13)) + .Append(']'); + sb.Append('}'); + } + + private static void WriteTreasureMaps(StringBuilder sb) + { + var enabled = Config.Get("TreasureMaps.Enabled", true); + + sb.Append(",\"treasureMaps\":{\"enabled\":").Append(Json(enabled)); + + if (enabled) + { + sb.Append(",\"lootChance\":").Append(Json(Config.Get("TreasureMaps.LootChance", 0.01))); + sb.Append(",\"resetDays\":").Append(Json(Config.Get("TreasureMaps.ResetTime", 30.0))); + } + + sb.Append('}'); + } + + private static void WriteVvV(StringBuilder sb) + { + if (!ViceVsVirtueSystem.Enabled) + return; + + sb.Append(",\"vvv\":{"); + sb.Append("\"enabled\":true"); + sb.Append(",\"startSilver\":").Append(ViceVsVirtueSystem.StartSilver); + sb.Append(",\"enhancedRules\":").Append(Json(ViceVsVirtueSystem.EnhancedRules)); + sb.Append('}'); + } + + /// + /// The Ultima Store. Only `enabled` and the currency's display name — never the store's + /// price table or any payment configuration, neither of which lives in Config anyway. + /// + private static void WriteStore(StringBuilder sb) + { + var enabled = Config.Get("Store.Enabled", true); + + sb.Append(",\"store\":{\"enabled\":").Append(Json(enabled)); + + if (enabled) + sb.Str("currencyName", Config.Get("Store.CurrencyName", "Sovereigns")); + + sb.Append('}'); + } + + /// + /// Save and restart schedule — "when does the shard hiccup?", the other question a live + /// status page is asked. Off behind RulesetIncludeSchedule for an operator who would rather + /// not advertise a predictable restart window. + /// + private static void WriteSchedule(StringBuilder sb) + { + sb.Append(",\"schedule\":{"); + + var saves = Config.Get("AutoSave.Enabled", true); + sb.Append("\"autoSaveEnabled\":").Append(Json(saves)); + + if (saves) + { + var freq = Config.Get("AutoSave.Frequency", TimeSpan.FromMinutes(5.0)); + sb.Append(",\"autoSaveFrequencyMinutes\":").Append((int)freq.TotalMinutes); + } + + var restart = Config.Get("AutoRestart.Enabled", false); + sb.Append(",\"autoRestartEnabled\":").Append(Json(restart)); + + if (restart) + { + sb.Append(",\"autoRestartHour\":").Append(Config.Get("AutoRestart.Hour", 12)); + sb.Append(",\"autoRestartMinute\":").Append(Config.Get("AutoRestart.Minute", 0)); + sb.Append(",\"autoRestartFrequencyHours\":").Append(Config.Get("AutoRestart.Frequency", 24)); + } + + sb.Append('}'); + } + + // ---- helpers ---- + + private static string Json(bool value) + { + return value ? "true" : "false"; + } + + private static string Json(double value) + { + return value.ToString("R", System.Globalization.CultureInfo.InvariantCulture); + } + + /// + /// FNV-1a over the UTF-16 code units of the body, as 8 lowercase hex digits. Any stable + /// hash would do; what matters is that it is stable ACROSS PROCESSES, which + /// String.GetHashCode() is not (it is seeded randomly per process), so using that would + /// produce a different rev after every restart and make the whole diff pointless. + /// + private static string Fnv1a(string s) + { + const uint offset = 2166136261; + const uint prime = 16777619; + + uint hash = offset; + + for (int i = 0; i < s.Length; i++) + { + char c = s[i]; + hash = (hash ^ (byte)(c & 0xFF)) * prime; + hash = (hash ^ (byte)(c >> 8)) * prime; + } + + return hash.ToString("x8"); + } + } +}