Lighting 26 28 38 1.2 16.5 0.3 0.2 -0.5 26 30 44 2200 260 12 true 48 52 68 0.5 3 Players 3 ReplicatedStorage Shared Challenges Config server remotes: `rate` requests/second --- with a burst allowance of `burst`. RemoteLimits = { Default = { rate = 5, burst = 10 }, RequestProfile = { rate = 1, burst = 3 }, EquipCosmetic = { rate = 4, burst = 8 }, UpdateSetting = { rate = 6, burst = 12 }, Rebirth = { rate = 0.5, burst = 2 }, }, } -------------------------------------------------------------------------------- -- Ranks and challenges (definitions live in Shared/Ranks.lua and -- Shared/Challenges.lua) -------------------------------------------------------------------------------- Config.Ranks = { --- Ranks at this ladder position or higher are announced to the whole server --- when someone unlocks them. AnnounceFromOrder = 6, --- Auto-equip the title and trail a rank grants if the player has nothing --- equipped yet. AutoEquipFirstReward = true, } Config.Challenges = { --- A finish only counts if the player crossed the start pad first, so the --- pads are the whole anti-skip mechanism. This is how long a start is --- remembered before it expires. RunTimeout = 240, --- Minimum seconds between two payouts on the same course, so standing on --- the finish pad cannot farm it. AwardCooldown = 2, --- Touch debounce per pad, per player. TouchDebounce = 0.35, --- Courses at or above this trophy value are announced server-wide. AnnounceFromTrophies = 10, --- How often the vanishing/door timers are stepped. 20 Hz is smooth enough --- for a 2 second cycle and costs almost nothing. TimerInterval = 0.05, } -------------------------------------------------------------------------------- -- Interface -------------------------------------------------------------------------------- Config.UI = { --- Global multiplier on every tween/animation duration. 0.5 == twice as --- fast. Players can scale this further in the settings panel. AnimationSpeed = 1, --- Stiffness of the exponential smoothing used for counting numbers up. NumberSmoothing = 9, --- Stiffness for progress bar fills. BarSmoothing = 7, FloatingTextLifetime = 1.15, FloatingTextRise = 4.5, --- Reward popups are merged while one is still on screen, so a player at 300 --- WalkSpeed sees "+6 Speed" instead of six overlapping labels. FloatingTextMergeWindow = 0.25, MaxFloatingTexts = 8, NotificationDuration = 4.5, MaxNotifications = 4, --- UI scales relative to this viewport size. ReferenceResolution = Vector2.new(1280, 720), MinScale = 0.75, MaxScale = 1.2, --- Below this viewport width the HUD switches to its compact layout. CompactWidth = 700, Sounds = { Enabled = true, --- rbxasset:// paths ship with the client, so there is nothing to upload --- and nothing that can 404 in production. Click = "rbxasset://sounds/electronicpingshort.wav", Reward = "rbxasset://sounds/electronicpingshort.wav", Trophy = "rbxasset://sounds/switch3.wav", }, } Config.Camera = { BaseFieldOfView = 70, MaxFieldOfView = 92, --- WalkSpeed at which the FOV kick reaches its maximum. FieldOfViewFullSpeed = 220, --- Exponential smoothing stiffness; low values feel floaty, high values snap. Smoothing = 3.5, --- Zoom limits scale up with speed so fast players can see further ahead. BaseMaxZoom = 40, FastMaxZoom = 64, } -------------------------------------------------------------------------------- -- World -------------------------------------------------------------------------------- Config.Map = { --- Square arena, centred on the origin. Big enough that a 300 WalkSpeed --- player still needs ~14 seconds to cross it. Size = 4096, TileSize = 512, --- Height of the invisible-topped boundary wall. WallHeight = 120, SpawnRadius = 90, --- Number of radial running lanes leaving the spawn plaza. LaneCount = 8, LaneWidth = 60, --- Ramps and arches scattered along each lane. PropsPerLane = 6, --- Pedestals showcasing each trophy, ringed around spawn. ShowcaseRadius = 140, --- MapService generates the whole world, so anything else in Workspace is --- competing with it -- most importantly the template Baseplate, a light grey --- plane sitting at exactly the height of our ground tiles. Set false if you --- are dropping this into a place that already has geometry you want to keep. ClearForeignWorld = true, --- Applied to Lighting on every server start by MapService, which also wipes --- any post-processing the place happens to carry. The project file sets the --- same values for the Studio edit view, but these are the ones that decide --- what a player actually sees -- so this is the block to turn when the game --- is too bright or too dark. Lighting = { ClockTime = 16.5, Brightness = 1.2, Ambient = Color3.fromRGB(26, 28, 38), OutdoorAmbient = Color3.fromRGB(48, 52, 68), --- The single strongest dial in the whole look. Negative is darker; --- every stop is a halving. ExposureCompensation = -0.5, EnvironmentDiffuseScale = 0.3, EnvironmentSpecularScale = 0.2, ShadowSoftness = 0.5, GeographicLatitude = 12, Bloom = { Intensity = 0.15, Size = 10, Threshold = 2.5 }, Atmosphere = { Density = 0.3, Offset = 0.05, Haze = 1, Glare = 0, Color = Color3.fromRGB(118, 128, 156), Decay = Color3.fromRGB(50, 56, 78), }, ColorCorrection = { Brightness = -0.06, Contrast = 0.2, Saturation = 0.1, TintColor = Color3.fromRGB(240, 240, 250), }, }, --- Muted but readable: a late-afternoon arena lit by the sun, not by its own --- markings. `Accent` is a painted colour, not an emissive one -- the only --- things that glow are the safe ring, the rank crystals, and the challenge --- pads, doors and vanishing floor. Palette = { Ground = Color3.fromRGB(44, 49, 66), GroundAlt = Color3.fromRGB(52, 58, 77), Lane = Color3.fromRGB(72, 84, 118), Accent = Color3.fromRGB(96, 168, 255), Plaza = Color3.fromRGB(38, 43, 58), Wall = Color3.fromRGB(28, 32, 45), }, } -------------------------------------------------------------------------------- -- Diagnostics -------------------------------------------------------------------------------- Config.Debug = { --- Extra print output from services. Verbose = false, --- Runs the pure-logic self test on server start. Studio only by default. RunSelfTests = RunService:IsStudio(), } return Util.deepFreeze(Config) ]]> Cosmetics Format "1,234" function Format.comma(value: number): string local whole = math.floor(math.abs(value)) local text = tostring(whole) local formatted = text while true do local replaced: number formatted, replaced = formatted:gsub("^(-?%d+)(%d%d%d)", "%1,%2") if replaced == 0 then break end end return (value < 0 and "-" or "") .. formatted end --- 1234 -> "1.23K". Keeps three significant digits like most simulators do. function Format.abbreviate(value: number): string local sign = value < 0 and "-" or "" local absolute = math.abs(value) if absolute < 1000 then -- Below 1000 we show whole numbers; fractions read as noise in a HUD. return sign .. tostring(math.floor(absolute)) end local index = math.floor(math.log(absolute, 1000)) index = math.clamp(index, 1, #SUFFIXES) local scaled = absolute / 1000 ^ index -- Floating point can leave us just under the next suffix (999,999 would -- otherwise render as "1000K" instead of "1M"). if scaled >= 1000 and index < #SUFFIXES then index += 1 scaled /= 1000 end local decimals = scaled < 10 and 2 or (scaled < 100 and 1 or 0) -- Trim trailing zeros so we get "1.5K" rather than "1.50K". local text = string.format("%." .. decimals .. "f", scaled) if text:find("%.") then text = text:gsub("0+$", ""):gsub("%.$", "") end return sign .. text .. SUFFIXES[index] end --- Studs -> a human readable distance. function Format.distance(studs: number): string if studs < 1000 then return string.format("%d studs", math.floor(studs)) end return Format.abbreviate(studs) .. " studs" end --- Seconds -> "1h 04m" / "12m 03s" / "45s" function Format.duration(seconds: number): string seconds = math.max(0, math.floor(seconds)) local hours = math.floor(seconds / 3600) local minutes = math.floor(seconds % 3600 / 60) local secs = seconds % 60 if hours > 0 then return string.format("%dh %02dm", hours, minutes) elseif minutes > 0 then return string.format("%dm %02ds", minutes, secs) end return string.format("%ds", secs) end --- 1.25 -> "x1.25" (drops the decimals when they are all zero) function Format.multiplier(value: number): string local text = string.format("%.2f", value) text = text:gsub("0+$", ""):gsub("%.$", "") return "x" .. text end --- 0.37 -> "37%" function Format.percent(alpha: number): string return string.format("%d%%", math.floor(alpha * 100 + 0.5)) end return Format ]]> Net server remote passes through a token bucket before the handler runs, so a spamming exploiter is dropped at the door. * Argument validation helpers live next to the transport, which makes "never trust the client" the easy thing to do at each call site. Directions are declared, not implied: firing a ClientToServer remote from the server (or vice versa) throws immediately in Studio instead of silently doing nothing in production. ]] local Players = game:GetService("Players") local ReplicatedStorage = game:GetService("ReplicatedStorage") local RunService = game:GetService("RunService") local Config = require(script.Parent.Config) local Signal = require(script.Parent.Signal) local IS_SERVER = RunService:IsServer() local FOLDER_NAME = "Remotes" local WAIT_TIMEOUT = 30 type Direction = "ServerToClient" | "ClientToServer" type RemoteSpec = { Class: "RemoteEvent" | "UnreliableRemoteEvent" | "RemoteFunction", Direction: Direction, --- Key into Config.AntiCheat.RemoteLimits; ClientToServer remotes only. Limit: string?, } local Net = {} --- Fires (player, remoteName) whenever a client exceeds its budget. --- AntiCheatService subscribes to this; Net itself never punishes. Net.RateLimited = Signal.new() Net.Specs = { --- Full authoritative state. Sent on join and whenever something structural --- changes (trophies, cosmetics, settings, rebirth). ProfileSync = { Class = "RemoteEvent", Direction = "ServerToClient" }, --- High frequency numeric stats. Unreliable on purpose: dropping a packet --- costs nothing because the next one carries the absolute value, and it --- keeps the reliable channel free for things that matter. StatStream = { Class = "UnreliableRemoteEvent", Direction = "ServerToClient" }, --- One reward payout, for the floating "+N" popup. RewardGranted = { Class = "RemoteEvent", Direction = "ServerToClient" }, RankUnlocked = { Class = "RemoteEvent", Direction = "ServerToClient" }, --- A challenge course was cleared: id, trophies paid, run time, best time. ChallengeCompleted = { Class = "RemoteEvent", Direction = "ServerToClient" }, --- Entering / leaving a course start pad, so the HUD can show what it needs. ChallengeState = { Class = "RemoteEvent", Direction = "ServerToClient" }, Notify = { Class = "RemoteEvent", Direction = "ServerToClient" }, RequestProfile = { Class = "RemoteFunction", Direction = "ClientToServer", Limit = "RequestProfile" }, EquipCosmetic = { Class = "RemoteEvent", Direction = "ClientToServer", Limit = "EquipCosmetic" }, UpdateSetting = { Class = "RemoteEvent", Direction = "ClientToServer", Limit = "UpdateSetting" }, Rebirth = { Class = "RemoteEvent", Direction = "ClientToServer", Limit = "Rebirth" }, } :: { [string]: RemoteSpec } local folder: Folder? = nil local cache: { [string]: Instance } = {} -------------------------------------------------------------------------------- -- Rate limiting -------------------------------------------------------------------------------- type Bucket = { tokens: number, updated: number } local buckets: { [Player]: { [string]: Bucket } } = {} local function getLimit(name: string) local spec = Net.Specs[name] local limits = Config.AntiCheat.RemoteLimits return (spec and spec.Limit and limits[spec.Limit]) or limits.Default end --- Classic token bucket: `rate` tokens refill per second up to `burst`. local function consume(player: Player, name: string): boolean local playerBuckets = buckets[player] if not playerBuckets then playerBuckets = {} buckets[player] = playerBuckets end local limit = getLimit(name) local now = os.clock() local bucket = playerBuckets[name] if not bucket then bucket = { tokens = limit.burst, updated = now } playerBuckets[name] = bucket else bucket.tokens = math.min(limit.burst, bucket.tokens + (now - bucket.updated) * limit.rate) bucket.updated = now end if bucket.tokens < 1 then return false end bucket.tokens -= 1 return true end if IS_SERVER then Players.PlayerRemoving:Connect(function(player) buckets[player] = nil end) end -------------------------------------------------------------------------------- -- Lifecycle -------------------------------------------------------------------------------- --- Server only. Creates the remote folder and every declared remote. function Net.init(): Folder assert(IS_SERVER, "Net.init may only be called on the server") if folder then return folder end local created = Instance.new("Folder") created.Name = FOLDER_NAME for name, spec in Net.Specs do local remote = Instance.new(spec.Class) remote.Name = name remote.Parent = created cache[name] = remote end created.Parent = ReplicatedStorage folder = created return created end local function getFolder(): Folder if folder then return folder end local found = ReplicatedStorage:WaitForChild(FOLDER_NAME, WAIT_TIMEOUT) assert(found, "Remotes folder never replicated -- is the server bootstrap running?") folder = found :: Folder return folder :: Folder end --- Looks up a remote by name, waiting for replication on the client. function Net.get(name: string): Instance local cached = cache[name] if cached then return cached end local spec = Net.Specs[name] assert(spec, `Unknown remote "{name}"`) local remote = getFolder():WaitForChild(name, WAIT_TIMEOUT) assert(remote, `Remote "{name}" never replicated`) cache[name] = remote return remote end local function expectDirection(name: string, direction: Direction) local spec = Net.Specs[name] assert(spec, `Unknown remote "{name}"`) assert(spec.Direction == direction, `Remote "{name}" is {spec.Direction}, not {direction}`) end -------------------------------------------------------------------------------- -- Server API -------------------------------------------------------------------------------- function Net.fireClient(name: string, player: Player, ...: any) expectDirection(name, "ServerToClient") local remote = Net.get(name) :: any remote:FireClient(player, ...) end function Net.fireAllClients(name: string, ...: any) expectDirection(name, "ServerToClient") local remote = Net.get(name) :: any remote:FireAllClients(...) end --- Connects a rate-limited handler. Requests over budget are dropped and --- reported through `Net.RateLimited`. function Net.onServerEvent(name: string, handler: (player: Player, ...any) -> ()): RBXScriptConnection expectDirection(name, "ClientToServer") local remote = Net.get(name) :: RemoteEvent return remote.OnServerEvent:Connect(function(player, ...) if not consume(player, name) then Net.RateLimited:Fire(player, name) return end handler(player, ...) end) end --- Same, for RemoteFunctions. A throttled invoke returns nil rather than --- erroring, so a laggy client degrades instead of breaking. function Net.onServerInvoke(name: string, handler: (player: Player, ...any) -> any) expectDirection(name, "ClientToServer") local remote = Net.get(name) :: RemoteFunction remote.OnServerInvoke = function(player, ...) if not consume(player, name) then Net.RateLimited:Fire(player, name) return nil end return handler(player, ...) end end -------------------------------------------------------------------------------- -- Client API -------------------------------------------------------------------------------- function Net.onClientEvent(name: string, handler: (...any) -> ()): RBXScriptConnection expectDirection(name, "ServerToClient") local remote = Net.get(name) :: any return remote.OnClientEvent:Connect(handler) end function Net.fireServer(name: string, ...: any) expectDirection(name, "ClientToServer") local remote = Net.get(name) :: RemoteEvent remote:FireServer(...) end function Net.invokeServer(name: string, ...: any): any expectDirection(name, "ClientToServer") local remote = Net.get(name) :: RemoteFunction return remote:InvokeServer(...) end -------------------------------------------------------------------------------- -- Argument guards -------------------------------------------------------------------------------- --- Returns the value only when it is a string within the length bound. --- Anything else (including nil, tables and 4 MB of junk) yields nil. function Net.readString(value: any, maxLength: number?): string? if type(value) ~= "string" then return nil end if #value > (maxLength or 64) then return nil end return value end function Net.readBoolean(value: any): boolean? if type(value) ~= "boolean" then return nil end return value end function Net.readNumber(value: any, min: number, max: number): number? if type(value) ~= "number" or value ~= value then return nil end if value < min or value > max then return nil end return value end return Net ]]> Progression timestamp then multiplier *= math.clamp(boost.Multiplier, 0, Config.Progression.MaxBoostMultiplier) end end return multiplier end --- Speed actually granted for one step, rounded so the HUD never shows a --- fractional stat. This is why Steps and Speed can drift apart late on: with a --- big enough multiplier one step is worth more than one Speed. function Progression.getSpeedPerStep(profile: Types.Profile, now: number?): number local raw = Config.Movement.SpeedPerStep * Progression.getSpeedMultiplier(profile, now) return math.max(1, math.floor(raw + 0.5)) end --- Exact (unrounded) value, for the "x1.35" multiplier readout. function Progression.getRawSpeedPerStep(profile: Types.Profile, now: number?): number return Config.Movement.SpeedPerStep * Progression.getSpeedMultiplier(profile, now) end function Progression.getRebirthCost(rebirths: number): number local progression = Config.Progression local cost = progression.RebirthBaseCost * progression.RebirthCostGrowth ^ math.max(rebirths, 0) return math.floor(cost + 0.5) end function Progression.canRebirth(profile: Types.Profile): (boolean, number) local cost = Progression.getRebirthCost(profile.Rebirths) return profile.Speed >= cost, cost end --- Applies a rebirth in place. Caller is responsible for having checked --- `canRebirth` first; this returns false rather than trusting it. function Progression.applyRebirth(profile: Types.Profile): boolean local allowed = Progression.canRebirth(profile) if not allowed then return false end for _, key in Config.Progression.RebirthResets do if key == "Speed" then profile.Speed = 0 elseif key == "Coins" then profile.Coins = 0 end end profile.Rebirths += 1 return true end --- Drops expired boosts. Returns true when the list changed. function Progression.pruneBoosts(profile: Types.Profile, now: number?): boolean local timestamp = now or os.time() local changed = false for index = #profile.Boosts, 1, -1 do local boost = profile.Boosts[index] if boost.ExpiresAt ~= 0 and boost.ExpiresAt <= timestamp then table.remove(profile.Boosts, index) changed = true end end return changed end --- Cosmetics unlocked by a rank, flattened for the award path. function Progression.collectRewards(definition: Types.RankDefinition): Types.RankRewards return definition.Rewards end function Progression.ownsTitle(profile: Types.Profile, id: string): boolean return profile.Titles[id] == true end function Progression.ownsTrail(profile: Types.Profile, id: string): boolean return profile.Trails[id] == true end return Progression ]]> Ranks earned by walking, makes you faster Trophies -> earned by clearing challenge courses (1 / 5 / 10 each) Rank -> unlocked by total trophies, pays out coins + cosmetics This is the file to edit when tuning the ladder. Everything else (the HUD rank card, the rank window, the world pedestals, the award check, the notification) is driven from this table. Adding a tier is a one-entry change: keep `Requirement` ascending and give it a stable, never-reused `Id` (ids are what gets written to the DataStore). ]] local Types = require(script.Parent.Types) local Ranks = {} --- Rarity drives border colour, glow strength and the label on the showcase. export type RarityStyle = { Name: string, Color: Color3, Glow: number } Ranks.Rarities = { Common = { Name = "Common", Color = Color3.fromRGB(154, 165, 177), Glow = 0.15 }, Uncommon = { Name = "Uncommon", Color = Color3.fromRGB(76, 217, 123), Glow = 0.25 }, Rare = { Name = "Rare", Color = Color3.fromRGB(76, 155, 255), Glow = 0.4 }, Epic = { Name = "Epic", Color = Color3.fromRGB(176, 97, 255), Glow = 0.55 }, Legendary = { Name = "Legendary", Color = Color3.fromRGB(255, 176, 32), Glow = 0.7 }, Mythic = { Name = "Mythic", Color = Color3.fromRGB(255, 77, 109), Glow = 0.85 }, Celestial = { Name = "Celestial", Color = Color3.fromRGB(56, 232, 224), Glow = 1 }, } :: { [string]: RarityStyle } --- Ordered ascending by Requirement (total trophies). `Order` is filled in below. --- Pacing note: one lap of all three courses pays 16 trophies, so Celestial is --- roughly 30 clean laps. Ranks.List = { { Id = "Bronze", Name = "Bronze", Rarity = "Common" :: Types.Rarity, Requirement = 1, Color = Color3.fromRGB(205, 127, 50), Accent = Color3.fromRGB(120, 70, 26), Description = "Your first trophy. Everyone starts here.", Rewards = { Coins = 250, Title = "Jogger", Trail = "Ember" }, Order = 0, }, { Id = "Silver", Name = "Silver", Rarity = "Uncommon" :: Types.Rarity, Requirement = 10, Color = Color3.fromRGB(216, 222, 233), Accent = Color3.fromRGB(130, 140, 155), Description = "Ten trophies. The gaps are starting to look small.", Rewards = { Coins = 750, Title = "Sprinter", Trail = "Frost", SpeedMultiplier = 0.05 }, Order = 0, }, { Id = "Gold", Name = "Gold", Rarity = "Rare" :: Types.Rarity, Requirement = 25, Color = Color3.fromRGB(255, 201, 60), Accent = Color3.fromRGB(176, 122, 12), Description = "You have cleared the Conveyors more than once.", Rewards = { Coins = 2500, Title = "Speedster", Trail = "Solar", SpeedMultiplier = 0.1 }, Order = 0, }, { Id = "Platinum", Name = "Platinum", Rarity = "Epic" :: Types.Rarity, Requirement = 50, Color = Color3.fromRGB(207, 233, 245), Accent = Color3.fromRGB(118, 156, 176), Description = "Fifty trophies. The Vanishing does not scare you.", Rewards = { Coins = 6000, Title = "Blur", Trail = "Prism", SpeedMultiplier = 0.15 }, Order = 0, }, { Id = "Diamond", Name = "Diamond", Rarity = "Legendary" :: Types.Rarity, Requirement = 100, Color = Color3.fromRGB(127, 231, 255), Accent = Color3.fromRGB(40, 132, 176), Description = "One hundred trophies. Unbreakable.", Rewards = { Coins = 15000, Title = "Supersonic", Trail = "Aurora", SpeedMultiplier = 0.25 }, Order = 0, }, { Id = "Mythic", Name = "Mythic", Rarity = "Mythic" :: Types.Rarity, Requirement = 250, Color = Color3.fromRGB(255, 77, 109), Accent = Color3.fromRGB(104, 20, 60), Description = "A rumour with footsteps.", Rewards = { Coins = 60000, Title = "MythicRunner", Trail = "Voidfire", SpeedMultiplier = 0.5 }, Order = 0, }, { Id = "Celestial", Name = "Celestial", Rarity = "Celestial" :: Types.Rarity, Requirement = 500, Color = Color3.fromRGB(56, 232, 224), Accent = Color3.fromRGB(24, 96, 130), Description = "You outran the horizon.", Rewards = { Coins = 200000, Title = "Celestial", Trail = "Starfall", SpeedMultiplier = 1 }, Order = 0, }, } :: { Types.RankDefinition } local byId: { [string]: Types.RankDefinition } = {} for index, definition in Ranks.List do definition.Order = index byId[definition.Id] = definition end Ranks.ById = byId Ranks.Count = #Ranks.List function Ranks.get(id: string): Types.RankDefinition? return byId[id] end function Ranks.getRarity(definition: Types.RankDefinition) return Ranks.Rarities[definition.Rarity] or Ranks.Rarities.Common end --- Highest rank the given trophy total qualifies for, or nil below the first. function Ranks.getCurrent(trophies: number): Types.RankDefinition? local current: Types.RankDefinition? = nil for _, definition in Ranks.List do if trophies >= definition.Requirement then current = definition else break end end return current end --- Next rank above the given trophy total, or nil once the ladder is complete. function Ranks.getNext(trophies: number): Types.RankDefinition? for _, definition in Ranks.List do if trophies < definition.Requirement then return definition end end return nil end --- Highest rank actually *unlocked*. This -- not `getCurrent` -- is what the HUD --- and the nametags display, so a rebirth (or any future trophy spend) can never --- take a rank away that was already earned. function Ranks.getHighestOwned(owned: { [string]: number }): Types.RankDefinition? local highest: Types.RankDefinition? = nil for _, definition in Ranks.List do if owned[definition.Id] ~= nil then highest = definition end end return highest end --- First rung of the ladder the player has not unlocked yet. function Ranks.getNextUnowned(owned: { [string]: number }): Types.RankDefinition? for _, definition in Ranks.List do if owned[definition.Id] == nil then return definition end end return nil end --- Progress along the ladder as the player experiences it: from the highest rank --- they hold toward the first one they do not. --- Returns (alpha, earned, needed, current, upcoming). function Ranks.getLadderProgress( trophies: number, owned: { [string]: number } ): (number, number, number, Types.RankDefinition?, Types.RankDefinition?) local current = Ranks.getHighestOwned(owned) local upcoming = Ranks.getNextUnowned(owned) local floor = current and current.Requirement or 0 if not upcoming then return 1, trophies, trophies, current, nil end local span = math.max(upcoming.Requirement - floor, 1) local earned = math.clamp(trophies - floor, 0, span) return earned / span, earned, span, current, upcoming end --- Every rank the trophy total qualifies for but that has not been credited yet. --- Runs on load as well as on award, so lowering a requirement retroactively --- grants it and there is no second code path that could disagree. function Ranks.getMissing(trophies: number, owned: { [string]: number }): { Types.RankDefinition } local missing = {} for _, definition in Ranks.List do if trophies >= definition.Requirement and owned[definition.Id] == nil then table.insert(missing, definition) end end return missing end return Ranks ]]> Schema boolean): { [string]: boolean } local owned: { [string]: boolean } = {} if type(source) == "table" then for id, value in source do if type(id) == "string" and value == true and exists(id) then owned[id] = true end end end return owned end profile.Titles = sanitizeOwnership(profile.Titles, function(id) return Cosmetics.Titles[id] ~= nil end) profile.Trails = sanitizeOwnership(profile.Trails, function(id) return Cosmetics.Trails[id] ~= nil end) -- Equipping something you do not own is not an error, it just unequips. if type(profile.EquippedTitle) ~= "string" or not profile.Titles[profile.EquippedTitle] then profile.EquippedTitle = "" end if type(profile.EquippedTrail) ~= "string" or not profile.Trails[profile.EquippedTrail] then profile.EquippedTrail = "" end local boosts: { Types.Boost } = {} if type(profile.Boosts) == "table" then for _, boost in profile.Boosts do if type(boost) == "table" and type(boost.Id) == "string" and #boosts < Config.Progression.MaxBoosts then table.insert(boosts, { Id = boost.Id, Multiplier = sanitizeFloat(boost.Multiplier, 1, 0, Config.Progression.MaxBoostMultiplier), ExpiresAt = sanitizeNumber(boost.ExpiresAt, 0, 0, MAX_STAT), }) end end end profile.Boosts = boosts local settings = profile.Settings settings.AnimationSpeed = sanitizeFloat(settings.AnimationSpeed, Config.UI.AnimationSpeed, 0.25, 3) settings.ShowEffects = settings.ShowEffects ~= false settings.ShowNametags = settings.ShowNametags ~= false settings.CompactHud = settings.CompactHud == true local stats = profile.Stats stats.Joins = sanitizeNumber(stats.Joins, 0, 0, MAX_STAT) stats.PlayTime = sanitizeNumber(stats.PlayTime, 0, 0, MAX_STAT) stats.Created = sanitizeNumber(stats.Created, os.time(), 0, MAX_STAT) stats.LastSeen = sanitizeNumber(stats.LastSeen, os.time(), 0, MAX_STAT) -- TotalSpeedEarned can never be behind current Speed; a rebirth lowers Speed -- but the lifetime total only ever grows. if profile.TotalSpeedEarned < profile.Speed then profile.TotalSpeedEarned = profile.Speed end return profile end --- Walks a stored profile up to the current VERSION. Each step is responsible --- only for its own hop, so the chain stays readable as versions accumulate. local migrations: { [number]: (any) -> any } = { --- v1 -> v2. In v1, `Trophies` was a dictionary of milestone ids unlocked by --- Speed. Those milestones are now the rank ladder, and `Trophies` is the --- challenge currency, so the old set moves across and the counter starts at --- zero -- nobody loses a badge they earned. [1] = function(profile) local legacy = profile.Trophies if type(legacy) == "table" then local ranks = type(profile.Ranks) == "table" and profile.Ranks or {} for id, unlockedAt in legacy do if type(id) == "string" and ranks[id] == nil then ranks[id] = unlockedAt end end profile.Ranks = ranks end profile.Trophies = 0 profile.Version = 2 return profile end, } function Schema.migrate(input: any): Types.Profile local profile = type(input) == "table" and input or {} local version = type(profile.Version) == "number" and profile.Version or Schema.VERSION while version < Schema.VERSION do local step = migrations[version] if not step then -- No explicit migration: reconcile handles purely additive changes. break end profile = step(profile) version += 1 end return Schema.sanitize(profile) end --- Everything the owning client is allowed to see. Today that is the whole --- profile; keeping the funnel explicit means adding a server-only field later --- cannot leak by accident. function Schema.toClientPayload(profile: Types.Profile): { [string]: any } return { Speed = profile.Speed, TotalSpeedEarned = profile.TotalSpeedEarned, Distance = profile.Distance, Steps = profile.Steps, Rebirths = profile.Rebirths, Coins = profile.Coins, Trophies = profile.Trophies, Ranks = Util.deepCopy(profile.Ranks), Challenges = Util.deepCopy(profile.Challenges), Titles = Util.deepCopy(profile.Titles), Trails = Util.deepCopy(profile.Trails), EquippedTitle = profile.EquippedTitle, EquippedTrail = profile.EquippedTrail, Boosts = Util.deepCopy(profile.Boosts), Settings = Util.deepCopy(profile.Settings), } end return Schema ]]> Signal (), } type ConnectionInternal = { Connected: boolean, _fn: (...any) -> (), _signal: any, Disconnect: (self: any) -> (), } local Connection = {} Connection.__index = Connection function Connection.Disconnect(self: ConnectionInternal) if not self.Connected then return end self.Connected = false local connections = self._signal._connections local index = table.find(connections, self) if index then table.remove(connections, index) end end export type Signal = { Connect: (self: Signal, fn: (T...) -> ()) -> Connection, Once: (self: Signal, fn: (T...) -> ()) -> Connection, Fire: (self: Signal, T...) -> (), Wait: (self: Signal) -> T..., DisconnectAll: (self: Signal) -> (), Destroy: (self: Signal) -> (), } function Signal.new(): Signal return (setmetatable({ _connections = {} }, Signal) :: any) :: Signal end function Signal:Connect(fn: (...any) -> ()): Connection local connection = setmetatable({ Connected = true, _fn = fn, _signal = self, }, Connection) table.insert(self._connections, connection) return (connection :: any) :: Connection end function Signal:Once(fn: (...any) -> ()): Connection local connection: Connection connection = self:Connect(function(...) connection:Disconnect() fn(...) end) return connection end function Signal:Fire(...: any) -- Iterate a copy: a handler is allowed to disconnect itself or others. local connections = table.clone(self._connections) for _, connection in connections do if connection.Connected then task.spawn(connection._fn, ...) end end end function Signal:Wait(): ...any local thread = coroutine.running() local connection: Connection connection = self:Connect(function(...) connection:Disconnect() task.spawn(thread, ...) end) return coroutine.yield() end function Signal:DisconnectAll() for _, connection in self._connections do connection.Connected = false end table.clear(self._connections) end function Signal:Destroy() self:DisconnectAll() end return Signal ]]> SpeedCurve curve.LinearUntil then bonus += (points - curve.LinearUntil) ^ curve.Exponent * curve.Coefficient end local count = math.max(rebirths or 0, 0) if count > 0 then bonus *= 1 + curve.RebirthWalkSpeedBonus * count end return bonus end --- The authoritative WalkSpeed for a given Speed stat. function SpeedCurve.walkSpeed(speed: number, rebirths: number?): number local movement = Config.Movement local total = movement.BaseWalkSpeed + SpeedCurve.bonus(speed, rebirths) return math.clamp(total, movement.BaseWalkSpeed, movement.MaxWalkSpeed) end --- True once extra Speed no longer converts into WalkSpeed. function SpeedCurve.isCapped(speed: number, rebirths: number?): boolean return SpeedCurve.walkSpeed(speed, rebirths) >= Config.Movement.MaxWalkSpeed end --- 0..1 position between the base and the maximum WalkSpeed. Drives the camera --- FOV kick and the speed lines. function SpeedCurve.intensity(walkSpeed: number): number local movement = Config.Movement local span = movement.MaxWalkSpeed - movement.BaseWalkSpeed if span <= 0 then return 0 end return math.clamp((walkSpeed - movement.BaseWalkSpeed) / span, 0, 1) end return SpeedCurve ]]> Types unix timestamp it was unlocked at. Ranks: { [string]: number }, --- Challenge id -> completions and best time. Challenges: { [string]: ChallengeRecord }, --- Cosmetic id -> owned. Titles: { [string]: boolean }, Trails: { [string]: boolean }, EquippedTitle: string, EquippedTrail: string, Boosts: { Boost }, Settings: PlayerSettings, Stats: ProfileStats, } --- Keys that are replicated to the owning client as plain numbers. export type NumericKey = "Speed" | "TotalSpeedEarned" | "Distance" | "Steps" | "Rebirths" | "Coins" | "Trophies" export type SessionLock = { JobId: string, PlaceId: number, At: number, } --- What actually lands in the DataStore. The profile is nested so we can store --- metadata beside it without polluting gameplay data. export type SaveEnvelope = { Schema: number, Data: Profile, Lock: SessionLock?, SavedAt: number, } export type LoadResult = { Profile: Profile, --- False when the datastore was unreachable and we handed back a fresh --- profile that must never be written back over real data. Persistent: boolean, IsNew: boolean, } return {} ]]> Util (source: T): T if type(source) ~= "table" then return source end local result = {} for key, value in source :: any do result[key] = Util.deepCopy(value) end return (result :: any) :: T end --- Fills in any key missing from `target` using `template`, recursively. --- This is how old saves pick up newly added fields without a bespoke migration. function Util.reconcile(target: { [any]: any }, template: T): T local result = {} for key, templateValue in template :: any do local targetValue = target[key] if type(templateValue) == "table" then if type(targetValue) == "table" then result[key] = Util.reconcile(targetValue, templateValue) else result[key] = Util.deepCopy(templateValue) end elseif targetValue ~= nil and type(targetValue) == type(templateValue) then result[key] = targetValue else result[key] = templateValue end end -- Preserve keys the template does not know about (dictionaries of ids such -- as owned trophies, titles and trails). for key, value in target do if result[key] == nil then result[key] = value end end return (result :: any) :: T end --- Recursively freezes a table so accidental writes fail loudly instead of --- silently changing balance at runtime. function Util.deepFreeze(value: T): T if type(value) ~= "table" then return value end for _, item in value :: any do Util.deepFreeze(item) end if not table.isfrozen(value :: any) then table.freeze(value :: any) end return value end --- Number of entries in a dictionary. function Util.count(dictionary: { [any]: any }): number local total = 0 for _ in dictionary do total += 1 end return total end --- Retries `fn` with exponential backoff and jitter. --- Returns `ok, result` where `result` is the error message on failure. function Util.retry( fn: () -> T, attempts: number, baseDelay: number, maxDelay: number, onFailure: ((attempt: number, err: any) -> ())? ): (boolean, any) local lastError: any = nil for attempt = 1, attempts do local ok, result = pcall(fn) if ok then return true, result end lastError = result if onFailure then onFailure(attempt, result) end if attempt < attempts then -- Deterministic backoff plus a little jitter so a wave of failing -- servers does not retry in lockstep. local delay = math.min(baseDelay * 2 ^ (attempt - 1), maxDelay) task.wait(delay * (0.75 + math.random() * 0.5)) end end return false, lastError end return Util ]]> ServerScriptService Server 0 0 then warn("[WalkForSpeed] Self test failures above -- balance logic is not behaving as configured.") end end print( string.format( "[WalkForSpeed] %s (%s) ready in %.0f ms.", Config.Game.Name, Config.Game.Version, (os.clock() - startedAt) * 1000 ) ) ]]> SelfTest v2 migration). None of it touches instances or DataStores, so it runs in a few milliseconds on server start (Studio only by default -- see Config.Debug.RunSelfTests) and catches the class of mistake that is otherwise invisible until a player has already been paid the wrong amount. ]] local ReplicatedStorage = game:GetService("ReplicatedStorage") local Shared = ReplicatedStorage:WaitForChild("Shared") local Challenges = require(Shared.Challenges) local Config = require(Shared.Config) local Format = require(Shared.Format) local Progression = require(Shared.Progression) local Ranks = require(Shared.Ranks) local Schema = require(Shared.Schema) local SpeedCurve = require(Shared.SpeedCurve) local Util = require(Shared.Util) local SelfTest = {} local passed = 0 local failures: { string } = {} local function check(name: string, condition: boolean, detail: string?) if condition then passed += 1 else table.insert(failures, if detail then `{name} -- {detail}` else name) end end local function checkEqual(name: string, actual: any, expected: any) check(name, actual == expected, `expected {tostring(expected)}, got {tostring(actual)}`) end local function checkClose(name: string, actual: number, expected: number, tolerance: number?) local epsilon = tolerance or 1e-6 check(name, math.abs(actual - expected) <= epsilon, `expected ~{expected}, got {actual}`) end -------------------------------------------------------------------------------- local function testFormat() checkEqual("Format.comma small", Format.comma(999), "999") checkEqual("Format.comma thousands", Format.comma(1234567), "1,234,567") checkEqual("Format.abbreviate under 1K", Format.abbreviate(999), "999") checkEqual("Format.abbreviate exact 1K", Format.abbreviate(1000), "1K") checkEqual("Format.abbreviate 1.5K", Format.abbreviate(1500), "1.5K") checkEqual("Format.abbreviate rollover", Format.abbreviate(999999), "1M") checkEqual("Format.abbreviate millions", Format.abbreviate(1234567), "1.23M") checkEqual("Format.multiplier trims", Format.multiplier(1.5), "x1.5") checkEqual("Format.multiplier whole", Format.multiplier(2), "x2") checkEqual("Format.duration minutes", Format.duration(125), "2m 05s") end local function testSpeedCurve() local movement = Config.Movement checkClose("Zero speed is base WalkSpeed", SpeedCurve.walkSpeed(0), movement.BaseWalkSpeed) check("Negative speed clamps to base", SpeedCurve.walkSpeed(-500) == movement.BaseWalkSpeed) local previous = -1 local monotonic = true for speed = 0, 200000, 977 do local value = SpeedCurve.walkSpeed(speed) if value < previous then monotonic = false break end previous = value end check("WalkSpeed never decreases as Speed rises", monotonic) check("WalkSpeed respects the cap", SpeedCurve.walkSpeed(1e9) <= movement.MaxWalkSpeed) check("Huge speed reaches the cap", SpeedCurve.isCapped(1e9)) check("A fresh player is not capped", not SpeedCurve.isCapped(0)) check("Rebirths make you faster", SpeedCurve.walkSpeed(1000, 1) > SpeedCurve.walkSpeed(1000, 0)) checkClose("Intensity at base is 0", SpeedCurve.intensity(movement.BaseWalkSpeed), 0) checkClose("Intensity at max is 1", SpeedCurve.intensity(movement.MaxWalkSpeed), 1) end local function testRanks() check("Ladder is not empty", #Ranks.List > 0) local ascending = true for index = 2, #Ranks.List do if Ranks.List[index].Requirement <= Ranks.List[index - 1].Requirement then ascending = false break end end check("Requirements ascend", ascending) local orderedIds = true for index, definition in Ranks.List do if definition.Order ~= index then orderedIds = false end if not Ranks.Rarities[definition.Rarity] then check(`Rarity exists for {definition.Id}`, false) end end check("Order matches ladder position", orderedIds) local first = Ranks.List[1] checkEqual("No rank below the first requirement", Ranks.getCurrent(first.Requirement - 1), nil) checkEqual("First rank unlocks at exactly its requirement", Ranks.getCurrent(first.Requirement), first) checkEqual("Next from zero is the first rank", Ranks.getNext(0), first) checkEqual("Nothing left after the last rank", Ranks.getNext(1e12), nil) local missing = Ranks.getMissing(first.Requirement, {}) checkEqual("Exactly one rank missing at the first requirement", #missing, 1) local owned = { [first.Id] = os.time() } checkEqual("Unlocked ranks are not re-awarded", #Ranks.getMissing(first.Requirement, owned), 0) -- Ownership-based ladder position (what the HUD and nametags display). checkEqual("Nothing owned means no current rank", Ranks.getHighestOwned {}, nil) checkEqual("Highest owned is reported", Ranks.getHighestOwned(owned), first) checkEqual("Next unowned from nothing is the first", Ranks.getNextUnowned {}, first) checkEqual("Next unowned skips what is owned", Ranks.getNextUnowned(owned), Ranks.List[2]) local everything: { [string]: number } = {} for _, definition in Ranks.List do everything[definition.Id] = 1 end checkEqual("Nothing left when the ladder is complete", Ranks.getNextUnowned(everything), nil) local freshAlpha, freshEarned, freshNeeded, freshCurrent, freshNext = Ranks.getLadderProgress(0, {}) checkEqual("Fresh player has no rank", freshCurrent, nil) checkEqual("Fresh player is climbing toward the first", freshNext, first) checkEqual("Fresh progress is zero", freshAlpha, 0) checkEqual("Fresh earned is zero", freshEarned, 0) checkEqual("Fresh target is the first requirement", freshNeeded, first.Requirement) -- A rank already held must survive the trophy total dropping below it. local _, _, _, afterSpend = Ranks.getLadderProgress(0, owned) checkEqual("A held rank is never taken away", afterSpend, first) local completeAlpha = Ranks.getLadderProgress(1e9, everything) checkEqual("A complete ladder reads as full", completeAlpha, 1) end local function testChallenges() check("There is at least one course", #Challenges.List > 0) local seenGaps: { [number]: boolean } = {} local seenIds: { [string]: boolean } = {} for index, definition in Challenges.List do checkEqual(`{definition.Id} order`, definition.Order, index) check(`{definition.Id} pays trophies`, definition.Trophies > 0) check(`{definition.Id} has a difficulty`, Challenges.Difficulties[definition.Difficulty] ~= nil) check(`{definition.Id} has a unique id`, not seenIds[definition.Id]) seenIds[definition.Id] = true -- Two courses in the same lane gap would build on top of each other. check(`{definition.Id} has a unique lane gap`, not seenGaps[definition.GapIndex]) seenGaps[definition.GapIndex] = true check( `{definition.Id} fits between the lanes`, definition.GapIndex >= 1 and definition.GapIndex <= Config.Map.LaneCount ) local length = Challenges.getCourseLength(definition) check(`{definition.Id} has length`, length > 0, `got {length}`) local minimum = Challenges.getMinimumRunTime(definition, Config.Movement.MaxWalkSpeed) check(`{definition.Id} minimum run time is positive`, minimum > 0) check( `{definition.Id} minimum run time is beatable`, minimum < length / definition.RecommendedWalkSpeed, "a legitimate run at the recommended speed must not be rejected" ) -- The course must sit past the rank pedestals and inside the walls. check(`{definition.Id} starts past the showcase`, definition.StartRadius > Config.Map.ShowcaseRadius) check(`{definition.Id} ends inside the arena`, definition.StartRadius + length + 80 < Config.Map.Size * 0.5) -- You must not be able to jump onto the course from the ground: the -- start pad is the only way in, and that is the whole anti-skip design. check(`{definition.Id} is above jump height`, definition.Height > Config.Movement.JumpHeight * 1.5) end -- Difficulty must actually cost more speed and pay more trophies. local previousSpeed, previousTrophies = 0, 0 local scaling = true for _, definition in Challenges.List do if definition.RecommendedWalkSpeed <= previousSpeed or definition.Trophies <= previousTrophies then scaling = false end previousSpeed = definition.RecommendedWalkSpeed previousTrophies = definition.Trophies end check("Harder courses need more speed and pay more", scaling) -- The widest Spacings gap has to be clearable at the speed it advertises. local spacings = Challenges.get("Spacings") if spacings then local widest, needed = Challenges.getHardestJump(spacings) check( `Widest gap is clearable at the advertised speed`, needed <= spacings.RecommendedWalkSpeed, `{widest} studs needs {math.ceil(needed)} studs/s, course advertises {spacings.RecommendedWalkSpeed}` ) end -- The courses have to connect to the ladder, or trophies go nowhere. local perLap = 0 for _, definition in Challenges.List do perLap += definition.Trophies end check("A full lap pays something", perLap > 0) check("The first rank is one lap or less away", Ranks.List[1].Requirement <= perLap) end local function testProgression() local profile = Schema.default() checkClose("Fresh multiplier is 1", Progression.getSpeedMultiplier(profile), 1) checkEqual( "A fresh step is worth the configured Speed", Progression.getSpeedPerStep(profile), Config.Movement.SpeedPerStep ) -- The whole point of the redesign: one step, one Speed, no hidden divisor. checkEqual("A step and a Speed point are the same event", Config.Movement.SpeedPerStep, 1) local bonusRank = nil for _, definition in Ranks.List do if definition.Rewards.SpeedMultiplier then bonusRank = definition break end end if bonusRank then profile.Ranks[bonusRank.Id] = os.time() checkClose( "Rank multipliers apply", Progression.getSpeedMultiplier(profile), 1 + (bonusRank.Rewards.SpeedMultiplier :: number) ) end local rebirthProfile = Schema.default() checkEqual("Rebirth cost at zero", Progression.getRebirthCost(0), Config.Progression.RebirthBaseCost) check("Rebirth cost grows", Progression.getRebirthCost(1) > Progression.getRebirthCost(0)) local allowed, cost = Progression.canRebirth(rebirthProfile) check("Cannot rebirth with no Speed", not allowed) rebirthProfile.Speed = cost check("Can rebirth at exactly the cost", (Progression.canRebirth(rebirthProfile))) check("Rebirth applies", Progression.applyRebirth(rebirthProfile)) checkEqual("Rebirth resets Speed", rebirthProfile.Speed, 0) checkEqual("Rebirth increments the counter", rebirthProfile.Rebirths, 1) local boosted = Schema.default() table.insert(boosted.Boosts, { Id = "Test", Multiplier = 2, ExpiresAt = 0 }) checkClose("Permanent boosts multiply", Progression.getSpeedMultiplier(boosted), 2) local expired = Schema.default() table.insert(expired.Boosts, { Id = "Old", Multiplier = 5, ExpiresAt = 100 }) checkClose("Expired boosts do not apply", Progression.getSpeedMultiplier(expired, 200), 1) check("Pruning removes expired boosts", Progression.pruneBoosts(expired, 200)) checkEqual("Boost list is empty after pruning", #expired.Boosts, 0) end local function testSchema() local clean = Schema.sanitize(nil) checkEqual("Sanitising nil yields a default profile", clean.Speed, 0) checkEqual("A fresh profile has no trophies", clean.Trophies, 0) local hostile = Schema.sanitize { Speed = -50, Trophies = -12, Distance = 0 / 0, Steps = math.huge, Coins = "lots", Ranks = { NotARealRank = 1, [1] = 2 }, Challenges = { NotARealCourse = { Completions = 5, BestTime = 1 }, Spacings = { Completions = 3, BestTime = 9 }, }, Titles = { NotARealTitle = true }, Trails = { Ember = true }, EquippedTrail = "Aurora", EquippedTitle = "Speedster", Boosts = { { Id = "X", Multiplier = 1e9, ExpiresAt = 0 } }, Settings = { AnimationSpeed = 1e6, ShowEffects = "yes" }, } checkEqual("Negative Speed clamps to zero", hostile.Speed, 0) checkEqual("Negative trophies clamp to zero", hostile.Trophies, 0) checkEqual("NaN distance falls back", hostile.Distance, 0) check("Infinite steps are rejected", hostile.Steps < math.huge) checkEqual("Non-numeric coins fall back", hostile.Coins, 0) checkEqual("Unknown ranks are dropped", Util.count(hostile.Ranks), 0) checkEqual("Unknown courses are dropped", Util.count(hostile.Challenges), 1) checkEqual("Known course records survive", hostile.Challenges.Spacings.Completions, 3) checkEqual("Unknown titles are dropped", Util.count(hostile.Titles), 0) checkEqual("Known trails survive", hostile.Trails.Ember, true) checkEqual("Equipping an unowned trail unequips", hostile.EquippedTrail, "") checkEqual("Equipping an unowned title unequips", hostile.EquippedTitle, "") check("Boost multipliers are capped", hostile.Boosts[1].Multiplier <= Config.Progression.MaxBoostMultiplier) check("Animation speed is clamped", hostile.Settings.AnimationSpeed <= 3) checkEqual("Bad booleans fall back to the default", hostile.Settings.ShowEffects, true) local carried = Schema.sanitize { Speed = 400, TotalSpeedEarned = 10 } check("Lifetime total is never behind current Speed", carried.TotalSpeedEarned >= carried.Speed) -- v1 stored Trophies as a dictionary of speed milestones. Those become -- ranks, and the trophy counter starts at zero. local legacy = Schema.migrate { Version = 1, Speed = 2600, Trophies = { Bronze = 1700000000, Silver = 1700000001, NotARealRank = 5 }, } checkEqual("Migration stamps the current version", legacy.Version, Schema.VERSION) checkEqual("Migration preserves Speed", legacy.Speed, 2600) checkEqual("Migration moves milestones to ranks", Util.count(legacy.Ranks), 2) check("Migration keeps a known rank", legacy.Ranks.Bronze ~= nil) checkEqual("Migration drops an unknown rank", legacy.Ranks.NotARealRank, nil) checkEqual("Migration resets the trophy counter", legacy.Trophies, 0) local current = Schema.migrate { Version = Schema.VERSION, Speed = 42, Trophies = 7 } checkEqual("A current profile is untouched", current.Speed, 42) checkEqual("A current trophy count survives", current.Trophies, 7) local payload = Schema.toClientPayload(Schema.default()) checkEqual("Client payload has no Version leak", payload.Version, nil) check("Client payload carries settings", payload.Settings ~= nil) check("Client payload carries ranks", payload.Ranks ~= nil) check("Client payload carries challenge records", payload.Challenges ~= nil) end local function testUtil() local merged = Util.reconcile({ a = 1, extra = "keep" }, { a = 0, b = 2 }) checkEqual("Reconcile keeps existing values", merged.a, 1) checkEqual("Reconcile fills missing values", merged.b, 2) checkEqual("Reconcile preserves unknown keys", merged.extra, "keep") local nested = Util.reconcile({ inner = { x = 5 } }, { inner = { x = 0, y = 1 } }) checkEqual("Reconcile recurses", nested.inner.y, 1) checkEqual("Reconcile keeps nested values", nested.inner.x, 5) local original = { list = { 1, 2, 3 } } local copy = Util.deepCopy(original) copy.list[1] = 99 checkEqual("deepCopy does not alias", original.list[1], 1) checkClose("damp converges", Util.damp(0, 10, 100, 1), 10, 0.01) checkEqual("mapClamped clamps high", Util.mapClamped(50, 0, 10, 0, 1), 1) checkEqual("mapClamped clamps low", Util.mapClamped(-50, 0, 10, 0, 1), 0) end -------------------------------------------------------------------------------- --- Returns (passed, failed). Also prints a summary. function SelfTest.run(): (number, number) passed = 0 table.clear(failures) local suites = { { "Format", testFormat }, { "SpeedCurve", testSpeedCurve }, { "Ranks", testRanks }, { "Challenges", testChallenges }, { "Progression", testProgression }, { "Schema", testSchema }, { "Util", testUtil }, } for _, suite in suites do local name = suite[1] :: string local ok, err = pcall(suite[2] :: () -> ()) if not ok then table.insert(failures, `{name} suite errored -- {err}`) end end if #failures == 0 then print(`[SelfTest] {passed} checks passed.`) else warn(`[SelfTest] {passed} passed, {#failures} FAILED:`) for _, failure in failures do warn(` - {failure}`) end end return passed, #failures end return SelfTest ]]> Services AntiCheatService 0 then record.score = math.max(0, record.score - elapsed * Config.AntiCheat.ViolationDecay) end end --- Records one violation. `weight` lets a blatant teleport count for more than --- a marginal displacement overrun. function AntiCheatService:Report(player: Player, kind: string, weight: number?) if not player.Parent then return end local record = getRecord(player) local now = os.clock() decay(record, now) record.score += weight or 1 record.counts[kind] = (record.counts[kind] or 0) + 1 local settings = Config.AntiCheat if not record.flagged and record.score >= settings.ViolationsBeforeFlag then record.flagged = true warn(`[AntiCheat] {player.Name} ({player.UserId}) flagged: {kind} x{record.counts[kind]}`) AntiCheatService.Flagged:Fire(player, kind, record.score) end if record.score >= settings.ViolationsBeforeAction then record.score = 0 record.flagged = false if settings.KickOnExploit then player:Kick("Kicked for abnormal movement. If this is a mistake, please rejoin.") else warn(`[AntiCheat] {player.Name} passed the action threshold via {kind}; rewards stay rejected.`) end end end --- Current (decayed) suspicion score. Useful for admin tooling and dashboards. function AntiCheatService:GetScore(player: Player): number local record = records[player] if not record then return 0 end decay(record, os.clock()) return record.score end function AntiCheatService:GetReport(player: Player): { [string]: number } local record = records[player] return record and table.clone(record.counts) or {} end function AntiCheatService:Init() -- A client that blows through its remote budget is the same kind of problem -- as one that teleports, so it lands on the same reputation score. Net.RateLimited:Connect(function(player: Player, remoteName: string) AntiCheatService:Report(player, `RateLimit:{remoteName}`, 2) end) Players.PlayerRemoving:Connect(function(player) records[player] = nil end) end return AntiCheatService ]]> ChallengeService 1 then addTimed(course, row, forward - bodyStart, params.Cycle, params.VisibleFraction, 0.3) end forward += params.RowSpacing end return forward - (params.RowSpacing - params.RowDepth) end -------------------------------------------------------------------------------- -- Assembly -------------------------------------------------------------------------------- local function buildStairs(course: Course, base: CFrame) local definition = course.definition local steps = math.max(math.ceil(definition.Height / 1.5), 1) local rise = definition.Height / steps -- The last step must land flush against the start pad (which begins at -- forward 0), or there is a hole in the approach at 20 studs up. for index = 1, steps do piece(base, { Name = `Step_{index}`, Parent = course.model, Forward = -4 * (steps - index) - 2, Height = rise * index - 1, Size = Vector3.new(4.5, 2, definition.Width), Color = Config.Map.Palette.Lane, Material = Enum.Material.Metal, }) end end local function buildCourse(definition: Types.ChallengeDefinition, parent: Instance): Course local angle = (definition.GapIndex - 0.5) * (math.pi * 2 / Config.Map.LaneCount) local direction = Vector3.new(math.cos(angle), 0, math.sin(angle)) -- Local +X runs away from spawn, local +Z is lateral. Every builder works in -- these coordinates, so none of them has to think about world angles. local base = CFrame.new(direction * definition.StartRadius) * CFrame.Angles(0, -angle, 0) local model = Instance.new("Model") model.Name = definition.Id local course: Course = { definition = definition, model = model, length = Challenges.getCourseLength(definition), minimumRunTime = Challenges.getMinimumRunTime(definition, Config.Movement.MaxWalkSpeed), timed = {}, } buildStairs(course, base) local difficulty = Challenges.getDifficulty(definition) local startPad = piece(base, { Name = "StartPad", Parent = model, Forward = 12, Height = definition.Height, Size = Vector3.new(24, 2, definition.Width), Color = Color3.fromRGB(76, 217, 123), Material = Enum.Material.Neon, Transparency = 0.2, }) startPad.CanTouch = true label( startPad, definition.Name, `{difficulty.Name} · +{definition.Trophies} {definition.Trophies == 1 and "Trophy" or "Trophies"}` .. ` · needs {definition.RecommendedWalkSpeed} studs/s`, difficulty.Color, 9 ) local bodyStart = 30 local bodyEnd = bodyStart if definition.Kind == "Spacings" then bodyEnd = buildSpacings(course, base, bodyStart) elseif definition.Kind == "Conveyors" then bodyEnd = buildConveyors(course, base, bodyStart) elseif definition.Kind == "Vanishing" then bodyEnd = buildVanishing(course, base, bodyStart) end local finishPad = piece(base, { Name = "FinishPad", Parent = model, Forward = bodyEnd + 14, Height = definition.Height, Size = Vector3.new(28, 2, definition.Width), Color = Color3.fromRGB(255, 201, 60), Material = Enum.Material.Neon, Transparency = 0.2, }) finishPad.CanTouch = true label(finishPad, "FINISH", `+{definition.Trophies}`, Color3.fromRGB(255, 201, 60), 9) -- Measure the real distance the builder laid down rather than trusting the -- estimate, so the "you cannot have run that fast" check stays honest if a -- course is retuned. course.length = bodyEnd - bodyStart course.minimumRunTime = course.length / Config.Movement.MaxWalkSpeed * 0.6 model.PrimaryPart = startPad model.Parent = parent return course end -------------------------------------------------------------------------------- -- Runs -------------------------------------------------------------------------------- local function tableFor(store: { [Player]: { [string]: number } }, player: Player): { [string]: number } local existing = store[player] if not existing then existing = {} store[player] = existing end return existing end local function debounced(player: Player, key: string): boolean local touches = tableFor(lastTouch, player) local now = os.clock() if now - (touches[key] or 0) < Config.Challenges.TouchDebounce then return true end touches[key] = now return false end local function onStart(player: Player, course: Course) local id = course.definition.Id if debounced(player, `start:{id}`) then return end tableFor(runs, player)[id] = os.clock() Net.fireClient("ChallengeState", player, { Id = id, Active = true }) end local function onFinish(player: Player, course: Course) local definition = course.definition local id = definition.Id if debounced(player, `finish:{id}`) then return end local playerRuns = tableFor(runs, player) local startedAt = playerRuns[id] if not startedAt then Net.fireClient("Notify", player, { Title = "Start at the green pad", Body = `{definition.Name} only counts if you run it from the start.`, Kind = "Warning", }) return end local elapsed = os.clock() - startedAt if elapsed > Config.Challenges.RunTimeout then playerRuns[id] = nil Net.fireClient("ChallengeState", player, { Id = id, Active = false }) Net.fireClient("Notify", player, { Title = "Run expired", Body = "That took a while -- start again from the green pad.", Kind = "Warning", }) return end if elapsed < course.minimumRunTime then -- Nothing can cross the course this fast, so something moved the -- character. No payout, and it goes on the record. AntiCheatService:Report(player, `Challenge:{id}`, 3) return end local awards = tableFor(lastAward, player) local now = os.clock() if now - (awards[id] or 0) < Config.Challenges.AwardCooldown then return end awards[id] = now playerRuns[id] = nil PlayerDataService:AddStat(player, "Trophies", definition.Trophies) local completions, bestTime, isBest = PlayerDataService:RecordChallenge(player, id, elapsed) Net.fireClient("ChallengeState", player, { Id = id, Active = false }) Net.fireClient("ChallengeCompleted", player, { Id = id, Trophies = definition.Trophies, Time = elapsed, BestTime = bestTime, PersonalBest = isBest, Completions = completions, }) if definition.Trophies >= Config.Challenges.AnnounceFromTrophies then local announcement = { Title = `{definition.Name} cleared!`, Body = `{player.DisplayName} took {Format.duration(elapsed)} for +{definition.Trophies} trophies.`, Kind = "Success", } for _, other in Players:GetPlayers() do if other ~= player then Net.fireClient("Notify", other, announcement) end end end ChallengeService.Completed:Fire(player, definition, elapsed) end local function bindPad(course: Course, pad: BasePart, handler: (Player, Course) -> ()) pad.Touched:Connect(function(hit) local character = hit.Parent if not character then return end local player = Players:GetPlayerFromCharacter(character) if not player or not PlayerDataService:IsLoaded(player) then return end handler(player, course) end) end -------------------------------------------------------------------------------- -- Timers -------------------------------------------------------------------------------- local function stepTimers() local now = workspace:GetServerTimeNow() for _, course in courses do for _, entry in course.timed do local position = (now + entry.phase) % entry.cycle local solid = position < entry.cycle * entry.solidFraction if solid ~= entry.solid then entry.solid = solid entry.part.CanCollide = solid entry.part.Transparency = if solid then entry.solidTransparency else entry.ghostTransparency end end end end -------------------------------------------------------------------------------- -- Lifecycle -------------------------------------------------------------------------------- function ChallengeService:GetCourse(id: string): Course? return courses[id] end function ChallengeService:Init() local existing = workspace:FindFirstChild("Challenges") if existing then existing:Destroy() end local folder = Instance.new("Folder") folder.Name = "Challenges" for _, definition in Challenges.List do local course = buildCourse(definition, folder) courses[definition.Id] = course local startPad = course.model:FindFirstChild("StartPad") :: BasePart? local finishPad = course.model:FindFirstChild("FinishPad") :: BasePart? if startPad then bindPad(course, startPad, onStart) end if finishPad then bindPad(course, finishPad, onFinish) end end folder.Parent = workspace RunService.PostSimulation:Connect(function(deltaTime) timerAccumulator += deltaTime if timerAccumulator < Config.Challenges.TimerInterval then return end timerAccumulator = 0 stepTimers() end) Players.PlayerRemoving:Connect(function(player) runs[player] = nil lastTouch[player] = nil lastAward[player] = nil end) if Config.Debug.Verbose then for id, course in courses do print(`[ChallengeService] {id}: {math.floor(course.length)} studs, min {course.minimumRunTime}s`) end end end return ChallengeService ]]> CosmeticService MapService 0 and (" | removed " .. table.concat(cleared, ", ")) or "", Lighting.ExposureCompensation, Lighting.Brightness ) ) end return MapService ]]> MockStore 0 then task.wait(self._latency) end end function MockStore:GetAsync(key: string): any self:_yield() return Util.deepCopy(self._data[key]) end function MockStore:SetAsync(key: string, value: any, userIds: { number }?): string self:_yield() self._data[key] = Util.deepCopy(value) self._keyInfo[key] = { UserIds = userIds } return key end function MockStore:UpdateAsync(key: string, transform: (any, any) -> ...any): ...any self:_yield() local current = Util.deepCopy(self._data[key]) local newValue, userIds = transform(current, self._keyInfo[key]) if newValue == nil then -- Matches the real service: returning nil cancels the write. return nil end self._data[key] = Util.deepCopy(newValue) self._keyInfo[key] = { UserIds = userIds } return Util.deepCopy(newValue) end function MockStore:RemoveAsync(key: string): any self:_yield() local previous = self._data[key] self._data[key] = nil self._keyInfo[key] = nil return Util.deepCopy(previous) end return MockStore ]]> MovementRewardService = tracker.nextWalkSpeedCheck then tracker.nextWalkSpeedCheck = now + Config.AntiCheat.WalkSpeedCheckInterval if math.abs(humanoid.WalkSpeed - authoritative) > Config.AntiCheat.WalkSpeedEpsilon then humanoid.WalkSpeed = authoritative end end local position = root.Position local offset = position - tracker.lastPosition tracker.lastPosition = position local distance = Vector3.new(offset.X, 0, offset.Z).Magnitude if distance <= 0 then tracker.airborneStreak = 0 return end local settings = Config.AntiCheat -- (2) Teleport: legal, but not walking. if distance > settings.TeleportDistance then return end -- (3) Faster than this player could possibly be. local allowance = authoritative * elapsed * settings.SpeedTolerance + settings.DistanceSlack if distance > allowance then AntiCheatService:Report(player, "Displacement", 1) return end -- (4) Airborne. if humanoid.SeatPart ~= nil then tracker.airborneStreak = 0 return end if Config.Movement.RequireGrounded and humanoid.FloorMaterial == Enum.Material.Air then if distance > Config.Movement.MinSpeedToCount * elapsed then tracker.airborneStreak += 1 if tracker.airborneStreak == settings.AirborneSamplesBeforeFlag then AntiCheatService:Report(player, "Flight", 4) end else tracker.airborneStreak = 0 end return end tracker.airborneStreak = 0 -- (5) Drift. if distance < Config.Movement.MinSpeedToCount * elapsed then return end -------------------------------------------------------------------------- -- Legitimate movement from here down. -------------------------------------------------------------------------- -- (3b) Credit at the honest rate, banking any surplus. local legitimate = authoritative * elapsed local credited = distance if credited > legitimate then local room = math.max(Config.AntiCheat.CreditCatchUpBank - tracker.catchUpBank, 0) tracker.catchUpBank += math.min(credited - legitimate, room) credited = legitimate elseif tracker.catchUpBank > 0 then local repay = math.min(tracker.catchUpBank, legitimate - credited) tracker.catchUpBank -= repay credited += repay end if credited <= 0 then return end PlayerDataService:AddStat(player, "Distance", credited) -- One step, one payout. tracker.stepAccumulator += credited local stride = Config.Movement.StudsPerStep if tracker.stepAccumulator < stride then return end local steps = math.floor(tracker.stepAccumulator / stride) if steps > Config.Movement.MaxStepsPerSample then -- Cannot happen given the displacement check above, but a balance change -- that lowers StudsPerStep should degrade, not explode. steps = Config.Movement.MaxStepsPerSample tracker.stepAccumulator = 0 else tracker.stepAccumulator -= steps * stride end PlayerDataService:AddStat(player, "Steps", steps) local gained = steps * Progression.getSpeedPerStep(profile) local total = PlayerDataService:AddSpeed(player, gained) Net.fireClient("RewardGranted", player, { Amount = gained, Steps = steps, Speed = total, }) end local function step(deltaTime: number) sampleAccumulator += deltaTime local interval = Config.Movement.SampleInterval if sampleAccumulator < interval then return end local elapsed = sampleAccumulator sampleAccumulator = 0 local now = os.clock() for _, tracker in trackers do sample(tracker, elapsed, now) end end -------------------------------------------------------------------------------- -- Lifecycle -------------------------------------------------------------------------------- function MovementRewardService:Init() local function bind(player: Player) player.CharacterAdded:Connect(function(character) task.spawn(onCharacterAdded, player, character) end) if player.Character then task.spawn(onCharacterAdded, player, player.Character) end end Players.PlayerAdded:Connect(bind) for _, player in Players:GetPlayers() do bind(player) end Players.PlayerRemoving:Connect(untrack) -- Speed changed: give the player their new WalkSpeed straight away rather -- than waiting for the next reconciliation tick. PlayerDataService.SpeedChanged:Connect(function(player: Player) applyWalkSpeed(player) end) -- Rebirths and boosts change the curve without changing Speed. PlayerDataService.StructureChanged:Connect(function(player: Player) applyWalkSpeed(player) end) PlayerDataService.ProfileLoaded:Connect(function(player: Player) applyWalkSpeed(player) end) RunService.PostSimulation:Connect(step) end return MovementRewardService ]]> PlayerCommandService server request in the game lands here, and every one of them is validated against the server's own copy of the profile before anything happens. The pattern for each handler is deliberately identical: read + type-check the arguments -> look up the live profile -> check the player is allowed -> mutate -> resync. Rate limiting happens one layer down in Net, so a handler never has to think about spam. ]] local ReplicatedStorage = game:GetService("ReplicatedStorage") local Shared = ReplicatedStorage:WaitForChild("Shared") local Config = require(Shared.Config) local Cosmetics = require(Shared.Cosmetics) local Net = require(Shared.Net) local Progression = require(Shared.Progression) local Schema = require(Shared.Schema) local PlayerDataService = require(script.Parent.PlayerDataService) local PlayerCommandService = {} --- Settings the client is allowed to change, with their validators. local SETTING_VALIDATORS: { [string]: (any) -> any } = { AnimationSpeed = function(value) return Net.readNumber(value, 0.25, 3) end, ShowEffects = function(value) return Net.readBoolean(value) end, ShowNametags = function(value) return Net.readBoolean(value) end, CompactHud = function(value) return Net.readBoolean(value) end, } local function notify(player: Player, title: string, body: string, kind: string?) Net.fireClient("Notify", player, { Title = title, Body = body, Kind = kind or "Info" }) end local function onEquipCosmetic(player: Player, kind: any, id: any) local kindName = Net.readString(kind, 16) local cosmeticId = Net.readString(id, 32) if not kindName or cosmeticId == nil then return end local profile = PlayerDataService:Get(player) if not profile then return end -- An empty id means "unequip", which is always allowed. if kindName == "Title" then if cosmeticId ~= "" then if not Cosmetics.getTitle(cosmeticId) or not Progression.ownsTitle(profile, cosmeticId) then return end end profile.EquippedTitle = cosmeticId elseif kindName == "Trail" then if cosmeticId ~= "" then if not Cosmetics.getTrail(cosmeticId) or not Progression.ownsTrail(profile, cosmeticId) then return end end profile.EquippedTrail = cosmeticId else return end PlayerDataService:MarkStructural(player) end local function onUpdateSetting(player: Player, key: any, value: any) local settingName = Net.readString(key, 32) if not settingName then return end local validator = SETTING_VALIDATORS[settingName] if not validator then return end local clean = validator(value) if clean == nil then return end local profile = PlayerDataService:Get(player) if not profile then return end (profile.Settings :: any)[settingName] = clean PlayerDataService:MarkStructural(player) end local function onRebirth(player: Player) if not Config.Progression.RebirthEnabled then return end local profile = PlayerDataService:Get(player) if not profile then return end local allowed, cost = Progression.canRebirth(profile) if not allowed then notify(player, "Not yet", `Rebirth needs {cost} Speed.`, "Warning") return end local ok, message = PlayerDataService:PerformRebirth(player) if ok then notify(player, "Rebirth!", `{message} -- your Speed multiplier grew.`, "Success") else notify(player, "Rebirth failed", message, "Warning") end end local function onRequestProfile(player: Player): { [string]: any }? local profile = PlayerDataService:Get(player) if not profile then return nil end return Schema.toClientPayload(profile) end function PlayerCommandService:Init() Net.onServerEvent("EquipCosmetic", onEquipCosmetic) Net.onServerEvent("UpdateSetting", onUpdateSetting) Net.onServerEvent("Rebirth", onRebirth) Net.onServerInvoke("RequestProfile", onRequestProfile) if Config.Debug.Verbose then print("[PlayerCommandService] Remote handlers bound.") end end return PlayerCommandService ]]> PlayerDataService (player: Player, mutator: (Types.Profile) -> T): T? local session = sessions[player] if not session then return nil end local result = mutator(session.profile) PlayerDataService:MarkStructural(player) return result end function PlayerDataService:PerformRebirth(player: Player): (boolean, string) local session = sessions[player] if not session then return false, "Profile not loaded" end local profile = session.profile local allowed, cost = Progression.canRebirth(profile) if not allowed then return false, `Requires {cost} Speed` end if not Progression.applyRebirth(profile) then return false, "Rebirth failed" end for _, key in NUMERIC_KEYS do session.dirtyStats[key] = true end session.structuralDirty = true session.attributesDirty = true PlayerDataService.SpeedChanged:Fire(player, profile.Speed) return true, `Rebirth {profile.Rebirths}` end -------------------------------------------------------------------------------- -- Saving -------------------------------------------------------------------------------- local function accruePlayTime(session: Session) local now = os.clock() session.profile.Stats.PlayTime += now - session.playStamp session.playStamp = now session.profile.Stats.LastSeen = os.time() end local function saveSession(session: Session, release: boolean): boolean if not session.persistent then return false end if session.saving then if not release then return false end -- A release save must not be skipped: wait out the autosave in flight. local deadline = os.clock() + 10 while session.saving and os.clock() < deadline do task.wait(0.1) end end session.saving = true accruePlayTime(session) local ok = SaveService:SaveAsync(session.userId, session.profile, release) session.saving = false session.nextAutosave = os.clock() + Config.Data.AutosaveInterval + math.random() * Config.Data.AutosaveJitter return ok end --- Forces a save for one player. Exposed for admin tooling and the self test. function PlayerDataService:SaveNow(player: Player, release: boolean?): boolean local session = sessions[player] if not session then return false end return saveSession(session, release == true) end -------------------------------------------------------------------------------- -- Lifecycle -------------------------------------------------------------------------------- local function onPlayerAdded(player: Player) if sessions[player] or loading[player] then return end loading[player] = true local result = SaveService:LoadAsync(player.UserId) loading[player] = nil if player.Parent == nil then -- They left mid-load. Drop the lock so their next server can have it. if result.Persistent then task.spawn(function() SaveService:ReleaseAsync(player.UserId) end) end return end local profile = result.Profile profile.Stats.Joins += 1 if result.IsNew then profile.Stats.Created = os.time() end local now = os.clock() local session: Session = { player = player, userId = player.UserId, profile = profile, persistent = result.Persistent, dirtyStats = {}, structuralDirty = false, attributesDirty = true, statSequence = 1, nextStatPush = now + Config.Replication.StatInterval, nextAttributePush = now, -- Stagger the first autosave so a full server does not write in lockstep. nextAutosave = now + Config.Data.AutosaveInterval + math.random() * Config.Data.AutosaveJitter, playStamp = now, saving = false, leaderstats = buildLeaderstats(player), } sessions[player] = session pushAttributes(session) pushProfile(session) PlayerDataService.ProfileLoaded:Fire(player, profile) if not result.Persistent then Net.fireClient("Notify", player, { Title = "Offline mode", Body = "Your progress cannot be saved right now.", Kind = "Warning", }) end end local function onPlayerRemoving(player: Player) local session = sessions[player] sessions[player] = nil if not session then -- Still loading: onPlayerAdded sees the nil Parent and releases the lock. return end PlayerDataService.ProfileReleasing:Fire(player, session.profile) -- Deliberately synchronous: Roblox waits on PlayerRemoving handlers, which -- is exactly the window we need for the final write to land. saveSession(session, true) end -------------------------------------------------------------------------------- -- Flush loop -------------------------------------------------------------------------------- local function step() local now = os.clock() for player, session in sessions do if session.structuralDirty then pushProfile(session) PlayerDataService.StructureChanged:Fire(player) end if now >= session.nextStatPush then session.nextStatPush = now + Config.Replication.StatInterval if next(session.dirtyStats) ~= nil then pushStats(session) end end if session.attributesDirty and now >= session.nextAttributePush then session.attributesDirty = false session.nextAttributePush = now + Config.Replication.AttributeInterval pushAttributes(session) end if not shuttingDown and now >= session.nextAutosave and not session.saving then -- Push the next slot forward immediately so a slow save cannot queue -- a second one behind it. session.nextAutosave = now + Config.Data.AutosaveInterval + math.random() * Config.Data.AutosaveJitter task.spawn(saveSession, session, false) end end end function PlayerDataService:Init() Players.PlayerAdded:Connect(function(player) task.spawn(onPlayerAdded, player) end) Players.PlayerRemoving:Connect(onPlayerRemoving) -- Anyone who joined while the server was still booting. for _, player in Players:GetPlayers() do task.spawn(onPlayerAdded, player) end RunService.PostSimulation:Connect(step) game:BindToClose(function() shuttingDown = true local pending = 0 local finished = 0 for _, session in sessions do pending += 1 task.spawn(function() saveSession(session, true) finished += 1 end) end if pending == 0 then return end local deadline = os.clock() + Config.Data.ShutdownTimeout while finished < pending and os.clock() < deadline do task.wait(0.1) end if finished < pending then warn(`[PlayerDataService] Shutdown timed out with {pending - finished} save(s) unfinished.`) end end) end return PlayerDataService ]]> RankService = Config.Ranks.AnnounceFromOrder then -- Everyone except the earner: they already got the personal popup, and -- two toasts for one unlock reads as a bug. local announcement = { Title = `{definition.Name} rank!`, Body = `{player.DisplayName} reached {definition.Requirement} trophies.`, Kind = "Rank", RankId = definition.Id, } for _, other in Players:GetPlayers() do if other ~= player then Net.fireClient("Notify", other, announcement) end end end RankService.Unlocked:Fire(player, definition) end --- Grants every rank the player now qualifies for. Cheap enough to call on --- every trophy change: the common case is one comparison. function RankService:Evaluate(player: Player) local profile = PlayerDataService:Get(player) if not profile then return end local missing = Ranks.getMissing(profile.Trophies, profile.Ranks) for _, definition in missing do unlock(player, profile, definition) end end --- Read-only summary. Exposed for admin tooling and future leaderboards. function RankService:GetProgress(player: Player): { [string]: any }? local profile = PlayerDataService:Get(player) if not profile then return nil end local alpha, earned, needed, current, upcoming = Ranks.getLadderProgress(profile.Trophies, profile.Ranks) return { CurrentId = current and current.Id or nil, NextId = upcoming and upcoming.Id or nil, Alpha = alpha, Earned = earned, Needed = needed, } end function RankService:Init() PlayerDataService.ProfileLoaded:Connect(function(player: Player) RankService:Evaluate(player) end) PlayerDataService.TrophiesChanged:Connect(function(player: Player, trophies: number) -- Fast path: the highest rank this trophy count qualifies for is almost -- always one the player already holds, and checking that costs a short -- loop and one table lookup instead of building a list. local current = Ranks.getCurrent(trophies) if not current then return end local profile = PlayerDataService:Get(player) if not profile or profile.Ranks[current.Id] ~= nil then return end RankService:Evaluate(player) end) end return RankService ]]> SaveService = deadline then return false end task.wait(0.4) end return true end function SaveService:Init() jobId = if game.JobId ~= "" then game.JobId else `studio-{game.PlaceId}-{os.time()}` if RunService:IsStudio() and Config.Data.UseMockStoreInStudio then usingMock = true store = MockStore.new() warn("[SaveService] Studio detected -- using the in-memory mock store. Live data is untouched.") return end local ok, result = pcall(function() return DataStoreService:GetDataStore(Config.Data.StoreName, Config.Data.Scope) end) if ok then store = result else usingMock = true store = MockStore.new(0) SaveService.Degraded = true warn(`[SaveService] GetDataStore failed ({result}) -- running non-persistent.`) end end -------------------------------------------------------------------------------- -- Loading -------------------------------------------------------------------------------- type Envelope = { Schema: number, Data: any, Lock: Types.SessionLock?, SavedAt: number, Build: string?, } local function isLockLive(lock: Types.SessionLock?): boolean if not lock then return false end if lock.JobId == jobId then return false end return os.time() - lock.At < Config.Data.SessionLockTimeout end --- Attempts to take ownership of a key. Returns the stored envelope on success --- and nil when another live server still holds the lock. local function acquire(userId: number): Envelope? local key = keyFor(userId) local ok, result = Util.retry( function() if not waitForBudget(Enum.DataStoreRequestType.UpdateAsync, 10) then error("UpdateAsync budget exhausted") end return store:UpdateAsync(key, function(current: any): ...any local envelope: Envelope = if type(current) == "table" then current else { Schema = Schema.VERSION, Data = nil, Lock = nil, SavedAt = 0 } if isLockLive(envelope.Lock) then -- Cancel the write; the caller will wait and try again. return nil end envelope.Lock = { JobId = jobId, PlaceId = game.PlaceId, At = os.time() } return envelope, { userId } end) end, Config.Data.MaxRetries, Config.Data.RetryBaseDelay, Config.Data.RetryMaxDelay, function(attempt, err) warn(`[SaveService] Load attempt {attempt} for {userId} failed: {err}`) end ) if not ok then return nil end return result end --- Loads (and locks) a profile. Always returns something playable. function SaveService:LoadAsync(userId: number): Types.LoadResult assert(store, "SaveService:Init was never called") local deadline = os.clock() + Config.Data.LockWaitTime local envelope: Envelope? = nil local lockedOut = false repeat envelope = acquire(userId) if envelope then break end -- Either the datastore errored (retry already exhausted) or another live -- server holds the lock. Both cases are worth one short wait. lockedOut = true task.wait(1.5) until os.clock() >= deadline if not envelope then warn(`[SaveService] Could not acquire a session for {userId}; running non-persistent.`) return { Profile = Schema.default(), Persistent = false, IsNew = true, } end if lockedOut then log("Recovered a stale session lock for %d", userId) end local isNew = envelope.Data == nil local profile = Schema.migrate(envelope.Data) return { Profile = profile, Persistent = true, IsNew = isNew, } end -------------------------------------------------------------------------------- -- Saving -------------------------------------------------------------------------------- --- Writes a profile. When `release` is true the session lock is dropped, which --- is what lets the player rejoin another server immediately. --- Returns false if the write failed or the lock had been taken by someone else. function SaveService:SaveAsync(userId: number, profile: Types.Profile, release: boolean): boolean assert(store, "SaveService:Init was never called") local key = keyFor(userId) local payload = Schema.sanitize(profile) local lostLock = false local ok, result = Util.retry( function() if not waitForBudget(Enum.DataStoreRequestType.UpdateAsync, 10) then error("UpdateAsync budget exhausted") end return store:UpdateAsync(key, function(current: any): ...any local envelope: Envelope = if type(current) == "table" then current else { Schema = Schema.VERSION, Data = nil, Lock = nil, SavedAt = 0 } local lock = envelope.Lock if lock and lock.JobId ~= jobId and os.time() - lock.At < Config.Data.SessionLockTimeout then -- Someone else owns this session now. Abort rather than -- overwrite whatever they have been doing. lostLock = true return nil end envelope.Schema = Schema.VERSION envelope.Data = payload envelope.SavedAt = os.time() envelope.Build = Config.Game.BuildTag envelope.Lock = if release then nil else { JobId = jobId, PlaceId = game.PlaceId, At = os.time() } return envelope, { userId } end) end, Config.Data.MaxRetries, Config.Data.RetryBaseDelay, Config.Data.RetryMaxDelay, function(attempt, err) warn(`[SaveService] Save attempt {attempt} for {userId} failed: {err}`) end ) if lostLock then warn(`[SaveService] Session lock for {userId} was taken by another server; save skipped.`) return false end if not ok then warn(`[SaveService] Save for {userId} failed permanently: {result}`) return false end log("Saved %d (release=%s)", userId, tostring(release)) return true end --- Drops the lock without writing gameplay data. Used when a player leaves --- before their profile finished loading. function SaveService:ReleaseAsync(userId: number): boolean assert(store, "SaveService:Init was never called") local ok = Util.retry(function() return store:UpdateAsync(keyFor(userId), function(current: any): ...any if type(current) ~= "table" then return nil end local lock = current.Lock if lock and lock.JobId ~= jobId then return nil end current.Lock = nil return current, { userId } end) end, 3, Config.Data.RetryBaseDelay, Config.Data.RetryMaxDelay) return ok end function SaveService:IsMock(): boolean return usingMock end return SaveService ]]> SoundService true StarterGui false HUD 10 1 false 2 1 Notifications 30 1 false 2 1 RanksUI 20 false 1 false 2 1 StarterPlayer 64 8 true StarterCharacterScripts StarterPlayerScripts Client ClientState Controllers CameraController 0.25 then player.CameraMaxZoomDistance = currentZoom end end local function onCharacterAdded(character: Model) humanoid = character:WaitForChild("Humanoid", 10) :: Humanoid? end function CameraController.start() -- Only used for the ceiling; the player still controls their own zoom. player.CameraMinZoomDistance = math.min(player.CameraMinZoomDistance, Config.Camera.BaseMaxZoom) if player.Character then task.spawn(onCharacterAdded, player.Character) end player.CharacterAdded:Connect(function(character) task.spawn(onCharacterAdded, character) end) RunService.PreRender:Connect(step) -- Sanity: a capped player should be at the widest FOV the config allows. if Config.Debug.Verbose then print( `[CameraController] FOV {Config.Camera.BaseFieldOfView}..{Config.Camera.MaxFieldOfView}`, `at up to {Config.Movement.MaxWalkSpeed} studs/s (curve caps at {SpeedCurve.walkSpeed(1e9)})` ) end end return CameraController ]]> EffectsController 0.1 -- Below a third of the range the effect is noise; above it, ramp hard so -- getting fast feels like it changed something. local ramp = math.clamp((intensity - 0.3) / 0.7, 0, 1) liveEmitter.Rate = if moving then ramp * ramp * 60 else 0 end -------------------------------------------------------------------------------- -- Reward popups -------------------------------------------------------------------------------- local function flushRewards() if pendingAmount <= 0 then return end local amount = pendingAmount local total = pendingTotal pendingAmount = 0 local part = root if not part or part.Parent == nil or not effectsEnabled() then return end -- "+1" on top, "24 Speed" underneath. FloatingText.spawn(part, `+{Format.abbreviate(amount)}`, `{Format.abbreviate(total)} Speed`, Theme.Color.Speed) -- Pitch rises with the size of the payout, so a big merged burst sounds -- different from a single reward. Sound.play("Reward", 1 + math.min(amount, 12) * 0.02, 0.2) end --- Clearing a course is the big payout, so it gets its own popup in trophy gold --- rather than being merged into the Speed stream. local function onChallengeCompleted(payload) if type(payload) ~= "table" then return end local part = root if not part or part.Parent == nil or not effectsEnabled() then return end local trophies = tonumber(payload.Trophies) or 0 if trophies <= 0 then return end FloatingText.spawn(part, `+{trophies}`, if trophies == 1 then "Trophy" else "Trophies", Theme.Color.Coin) end local function onReward(payload) if type(payload) ~= "table" then return end local amount = tonumber(payload.Amount) or 0 if amount <= 0 then return end pendingAmount += amount pendingTotal = tonumber(payload.Speed) or (pendingTotal + amount) local now = os.clock() if pendingUntil <= now then pendingUntil = now + Config.UI.FloatingTextMergeWindow end end -------------------------------------------------------------------------------- -- Character tracking -------------------------------------------------------------------------------- local function onCharacterAdded(character: Model) root = character:WaitForChild("HumanoidRootPart", 10) :: BasePart? humanoid = character:WaitForChild("Humanoid", 10) :: Humanoid? emitter = nil if root and player.Character == character then emitter = buildEmitter(root) end end local function step() local now = os.clock() if pendingAmount > 0 and now >= pendingUntil then flushRewards() end if now >= nextParticleUpdate then -- 10 Hz is plenty for a particle rate and keeps this loop off the -- per-frame budget. nextParticleUpdate = now + 0.1 updateParticles() end end function EffectsController.start() if player.Character then task.spawn(onCharacterAdded, player.Character) end player.CharacterAdded:Connect(function(character) task.spawn(onCharacterAdded, character) end) Net.onClientEvent("RewardGranted", onReward) Net.onClientEvent("ChallengeCompleted", onChallengeCompleted) RunService.PostSimulation:Connect(step) end return EffectsController ]]> NametagController UIController server ------------------------------------------------------------------ hud:on("Ranks", toggleRanks) hud:on("Settings", toggleSettings) hud:on("Rebirth", function() Net.fireServer("Rebirth") end) rankWindow:on("Equip", function(kind: string, id: string) Net.fireServer("EquipCosmetic", kind, id) end) settingsWindow:on("Changed", function(key: string, value: any) Net.fireServer("UpdateSetting", key, value) -- Apply locally straight away so the control feels instant; the server -- echo confirms it a moment later. if key == "AnimationSpeed" then Motion.speed = value elseif key == "ShowEffects" then ClientState.profile.Settings.ShowEffects = value ClientState.Changed:Fire(ClientState.profile) elseif key == "ShowNametags" then ClientState.profile.Settings.ShowNametags = value ClientState.Changed:Fire(ClientState.profile) elseif key == "CompactHud" then ClientState.profile.Settings.CompactHud = value applyLayout() end end) ------------------------------------------------------------------ -- Server -> UI ------------------------------------------------------------------ Net.onClientEvent("Notify", function(payload) notifications:push(payload) end) Net.onClientEvent("RankUnlocked", function(payload) local definition = payload and Ranks.get(payload.Id) if not definition then return end notifications:push { Title = `{definition.Name} rank unlocked!`, Body = definition.Description, Kind = "Rank", RankId = definition.Id, } Sound.play("Trophy", 1, 0.45) hud:pulseTrophies() end) Net.onClientEvent("RewardGranted", function(payload) if type(payload) == "table" and payload.Amount then hud:pulse() end end) -- A course run started or ended. Only the banner needs to know. Net.onClientEvent("ChallengeState", function(payload) if type(payload) ~= "table" then return end hud:setChallenge(if payload.Active then payload.Id else nil) end) Net.onClientEvent("ChallengeCompleted", function(payload) local definition = payload and Challenges.get(payload.Id) if not definition then return end hud:setChallenge(nil) hud:pulseTrophies() Sound.play("Trophy", 1.1, 0.4) local time = string.format("%.1fs", payload.Time or 0) local body = if payload.PersonalBest then `New best: {time} · +{payload.Trophies} trophies` else `{time} · +{payload.Trophies} trophies` notifications:push { Title = `{definition.Name} cleared!`, Body = body, Kind = "Success", } end) ------------------------------------------------------------------ -- Layout + input ------------------------------------------------------------------ ClientState.Changed:Connect(render) render(ClientState.profile) applyLayout() local camera = workspace.CurrentCamera if camera then camera:GetPropertyChangedSignal("ViewportSize"):Connect(applyLayout) end workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function() local newCamera = workspace.CurrentCamera if newCamera then newCamera:GetPropertyChangedSignal("ViewportSize"):Connect(applyLayout) applyLayout() end end) bindActions() UserInputService.LastInputTypeChanged:Connect(function() if not usingGamepad() then GuiService.SelectedObject = nil elseif anyWindowOpen() then focus( if rankWindow:isOpen() then rankWindow:getPrimarySelection() else settingsWindow:getPrimarySelection() ) end end) rankWindow:on("Closed", function() focus(hud:getPrimarySelection()) end) settingsWindow:on("Closed", function() focus(hud:getPrimarySelection()) end) end return UIController ]]> UI Components (), setText: (text: string) -> (), } --- A labelled number that counts toward its new value instead of snapping. function Components.statRow(props: { [string]: any }): StatRow local formatter = props.Formatter or Format.abbreviate local row = New("Frame") { Name = props.Name or "StatRow", Parent = props.Parent, BackgroundTransparency = 1, Size = props.Size or UDim2.new(1, 0, 0, 22), LayoutOrder = props.LayoutOrder, } New("Frame") { Name = "Dot", Parent = row, AnchorPoint = Vector2.new(0, 0.5), Position = UDim2.new(0, 0, 0.5, 0), Size = UDim2.fromOffset(6, 6), BackgroundColor3 = props.Color or Theme.Color.Accent, New.corner(Theme.Radius.Pill), } Components.label { Parent = row, Name = "Title", Text = props.Title or "", Color = Theme.Color.TextMuted, Font = Theme.Font.Medium, TextSize = props.TextSize or 15, Position = UDim2.fromOffset(14, 0), Size = UDim2.new(1, -14, 1, 0), } local value = Components.label { Parent = row, Name = "Value", Text = formatter(0), Color = props.Color or Theme.Color.Text, Font = Theme.Font.Bold, TextSize = props.TextSize or 15, Size = UDim2.new(1, 0, 1, 0), XAlign = Enum.TextXAlignment.Right, } local counter = Motion.numberLabel(value, function(current) return formatter(current) end) return { Instance = row, set = function(target: number) counter:set(target) end, setText = function(text: string) counter:snap(0) value.Text = text end, } end export type ProgressBar = { Instance: Frame, Fill: Frame, setAlpha: (alpha: number) -> (), setColor: (color: ColorSequence) -> (), } function Components.progressBar(props: { [string]: any }?): ProgressBar local settings = props or {} local track = New("Frame") { Name = settings.Name or "ProgressBar", Parent = settings.Parent, Size = settings.Size or UDim2.new(1, 0, 0, 14), Position = settings.Position, AnchorPoint = settings.AnchorPoint, LayoutOrder = settings.LayoutOrder, BackgroundColor3 = Theme.Color.PanelSunken, BorderSizePixel = 0, ClipsDescendants = true, New.corner(Theme.Radius.Pill), New.stroke(Theme.Color.StrokeSoft, 1, 0.4), } local fill = New("Frame") { Name = "Fill", Parent = track, Size = UDim2.fromScale(0, 1), BackgroundColor3 = Color3.new(1, 1, 1), BorderSizePixel = 0, New.corner(Theme.Radius.Pill), } local gradient = New.gradient(settings.Gradient or Theme.SpeedGradient, 0) gradient.Parent = fill local counter = Motion.barFill(fill) return { Instance = track, Fill = fill, setAlpha = function(alpha: number) counter:set(math.clamp(alpha, 0, 1)) end, setColor = function(color: ColorSequence) gradient.Color = color end, } end -------------------------------------------------------------------------------- -- Controls -------------------------------------------------------------------------------- export type Button = { Instance: TextButton, setText: (text: string) -> (), setEnabled: (enabled: boolean) -> (), setColor: (color: Color3) -> (), } --- Wires hover, press and gamepad-selection feedback onto one button. local function attachInteraction(button: GuiButton, stroke: UIStroke, getColor: () -> Color3) local hovering = false local pressed = false local function refresh() local base = getColor() local target = base if pressed then target = Theme.darken(base, 0.18) elseif hovering then target = Theme.lighten(base, 0.14) end Motion.tween(button, { BackgroundColor3 = target }, 0.14) Motion.tween(stroke, { Transparency = hovering and 0 or 0.45, Thickness = hovering and 2 or 1 }, 0.14) end button.MouseEnter:Connect(function() hovering = true refresh() end) button.MouseLeave:Connect(function() hovering = false pressed = false refresh() end) -- Gamepad focus uses the same visual as a mouse hover. button.SelectionGained:Connect(function() hovering = true refresh() end) button.SelectionLost:Connect(function() hovering = false refresh() end) button.MouseButton1Down:Connect(function() pressed = true refresh() end) button.MouseButton1Up:Connect(function() pressed = false refresh() end) button.TouchTap:Connect(function() Motion.tween(stroke, { Thickness = 3 }, 0.08) Motion.tween(stroke, { Thickness = 1 }, 0.25) end) refresh() end function Components.button(props: { [string]: any }): Button local color = props.Color or Theme.Color.Accent local enabled = true local button = New("TextButton") { Name = props.Name or "Button", Parent = props.Parent, Size = props.Size or UDim2.new(1, 0, 0, 40), Position = props.Position, AnchorPoint = props.AnchorPoint, LayoutOrder = props.LayoutOrder, BackgroundColor3 = color, BorderSizePixel = 0, AutoButtonColor = false, Text = props.Text or "", TextColor3 = props.TextColor or Theme.Color.Text, FontFace = props.Font or Theme.Font.Bold, TextSize = props.TextSize or 17, TextScaled = props.TextScaled or false, -- Gamepad: every button is reachable by the D-pad. Selectable = true, New.corner(props.Radius or Theme.Radius.Medium), } local stroke = New.stroke(Theme.lighten(color, 0.4), 1, 0.45) stroke.Parent = button if props.Gradient ~= false then New.gradient(Theme.PanelGradient, 90, NumberSequence.new(0, 0.12)).Parent = button end local function currentColor(): Color3 return if enabled then color else Theme.Color.Locked end attachInteraction(button, stroke, currentColor) button.Activated:Connect(function() if not enabled then return end Sound.play("Click", 1, 0.25) if props.OnClick then props.OnClick() end end) -- Both setters are idempotent. They are called from render paths that run -- several times a second, and starting a tween per call would mean the -- button never settles and the tween pool never drains. return { Instance = button, setText = function(text: string) if button.Text ~= text then button.Text = text end end, setEnabled = function(value: boolean) if enabled == value then return end enabled = value button.Selectable = value button.TextTransparency = value and 0 or 0.35 Motion.tween(button, { BackgroundColor3 = currentColor() }, 0.16) end, setColor = function(value: Color3) if color == value then return end color = value Motion.tween(button, { BackgroundColor3 = currentColor() }, 0.16) end, } end export type Toggle = { Instance: Frame, set: (value: boolean) -> (), get: () -> boolean, } function Components.toggle(props: { [string]: any }): Toggle local value = props.Value == true local row = New("Frame") { Name = props.Name or "Toggle", Parent = props.Parent, BackgroundTransparency = 1, Size = props.Size or UDim2.new(1, 0, 0, 38), LayoutOrder = props.LayoutOrder, } Components.label { Parent = row, Name = "Title", Text = props.Title or "", Color = Theme.Color.Text, Font = Theme.Font.Medium, TextSize = 16, Size = UDim2.new(1, -70, 1, 0), } local switch = New("TextButton") { Name = "Switch", Parent = row, AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, 0, 0.5, 0), Size = UDim2.fromOffset(58, 28), BackgroundColor3 = Theme.Color.PanelSunken, BorderSizePixel = 0, AutoButtonColor = false, Text = "", Selectable = true, New.corner(Theme.Radius.Pill), } local stroke = New.stroke(Theme.Color.Stroke, 1, 0.4) stroke.Parent = switch local knob = New("Frame") { Name = "Knob", Parent = switch, AnchorPoint = Vector2.new(0, 0.5), Position = UDim2.new(0, 3, 0.5, 0), Size = UDim2.fromOffset(22, 22), BackgroundColor3 = Theme.Color.TextMuted, BorderSizePixel = 0, New.corner(Theme.Radius.Pill), } local function render(animated: boolean) local position = if value then UDim2.new(1, -25, 0.5, 0) else UDim2.new(0, 3, 0.5, 0) local knobColor = if value then Theme.Color.Text else Theme.Color.TextMuted local trackColor = if value then Theme.Color.Success else Theme.Color.PanelSunken if animated then Motion.tween(knob, { Position = position, BackgroundColor3 = knobColor }, 0.2, Enum.EasingStyle.Back) Motion.tween(switch, { BackgroundColor3 = trackColor }, 0.2) else knob.Position = position knob.BackgroundColor3 = knobColor switch.BackgroundColor3 = trackColor end end switch.Activated:Connect(function() value = not value render(true) Sound.play("Click", value and 1.1 or 0.9, 0.25) if props.OnChanged then props.OnChanged(value) end end) attachInteraction(switch, stroke, function() return if value then Theme.Color.Success else Theme.Color.PanelSunken end) render(false) return { Instance = row, set = function(newValue: boolean) if value == newValue then return end value = newValue render(true) end, get = function(): boolean return value end, } end export type Segmented = { Instance: Frame, set: (value: any) -> (), } --- A row of mutually exclusive options. Preferred over a drag slider because it --- works identically with a mouse, a thumb and a D-pad. function Components.segmented(props: { [string]: any }): Segmented local options = props.Options or {} local selected = props.Value local row = New("Frame") { Name = props.Name or "Segmented", Parent = props.Parent, BackgroundTransparency = 1, Size = props.Size or UDim2.new(1, 0, 0, 58), LayoutOrder = props.LayoutOrder, } Components.label { Parent = row, Name = "Title", Text = props.Title or "", Color = Theme.Color.Text, Font = Theme.Font.Medium, TextSize = 16, Size = UDim2.new(1, 0, 0, 20), } local strip = New("Frame") { Name = "Options", Parent = row, Position = UDim2.new(0, 0, 0, 24), Size = UDim2.new(1, 0, 0, 32), BackgroundTransparency = 1, New.list { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 6), HorizontalAlignment = Enum.HorizontalAlignment.Left, }, } local buttons: { [any]: any } = {} local function render() for value, entry in buttons do local active = value == selected entry.setColor(if active then Theme.Color.Accent else Theme.Color.PanelSunken) end end for index, option in options do local entry entry = Components.button { Parent = strip, Name = tostring(option.Value), Text = option.Label, TextSize = 14, LayoutOrder = index, Size = UDim2.new(0, 74, 1, 0), Radius = Theme.Radius.Small, Color = Theme.Color.PanelSunken, OnClick = function() selected = option.Value render() if props.OnChanged then props.OnChanged(option.Value) end end, } buttons[option.Value] = entry end render() return { Instance = row, set = function(value: any) if selected == value then return end selected = value render() end, } end return Components ]]> FloatingText = Config.UI.MaxFloatingTexts then return nil end local billboard = table.remove(pool) if not billboard then billboard = build() end active += 1 return billboard end local function release(billboard: BillboardGui) billboard.Enabled = false billboard.Adornee = nil active -= 1 table.insert(pool, billboard) end local function fade(label: TextLabel, lifetime: number) label.TextTransparency = 0 Motion.tween(label, { TextTransparency = 1 }, lifetime, Enum.EasingStyle.Quad, Enum.EasingDirection.In) local stroke = label:FindFirstChildOfClass("UIStroke") if stroke then stroke.Transparency = 0.1 Motion.tween(stroke, { Transparency = 1 }, lifetime, Enum.EasingStyle.Quad, Enum.EasingDirection.In) end end --- Spawns one popup above `adornee`. --- `gain` is the headline ("+1"), `total` the line underneath ("24 Speed"). function FloatingText.spawn(adornee: BasePart, gain: string, total: string?, color: Color3?) local billboard = acquire() if not billboard then return end local gainLabel = billboard:FindFirstChild("Gain") :: TextLabel local totalLabel = billboard:FindFirstChild("Total") :: TextLabel gainLabel.Text = gain gainLabel.TextColor3 = color or Theme.Color.Speed totalLabel.Text = total or "" totalLabel.Visible = total ~= nil and total ~= "" -- A little horizontal scatter so a burst reads as several rewards rather -- than one label flickering. local scatter = (math.random() - 0.5) * 2.4 billboard.StudsOffsetWorldSpace = Vector3.new(scatter, 2.6, 0) billboard.Adornee = adornee billboard.Enabled = true local lifetime = Config.UI.FloatingTextLifetime Motion.tween( billboard, { StudsOffsetWorldSpace = Vector3.new(scatter * 1.6, 2.6 + Config.UI.FloatingTextRise, 0) }, lifetime, Enum.EasingStyle.Quad, Enum.EasingDirection.Out ) fade(gainLabel, lifetime) fade(totalLabel, lifetime) task.delay(Motion.duration(lifetime) + 0.05, function() release(billboard) end) end return FloatingText ]]> HUD string)?) self.rows[name] = Components.statRow { Parent = panel, Name = name, Title = title, Color = color, LayoutOrder = order, Formatter = formatter, } end row("Steps", "Steps taken", Theme.Color.AccentDeep, 6, Format.comma) row("Reward", "Speed per step", Theme.Color.Speed, 7, function(value) return `+{Format.abbreviate(value)}` end) row("Distance", "Distance walked", Theme.Color.Accent, 8, Format.distance) row("Coins", "Coins", Theme.Color.Coin, 9) row("Rebirths", "Rebirths", Theme.Color.Warning, 10, Format.comma) end function HUD:_buildRankCard() local card = Components.panel { Parent = self.root, Name = "RankCard", AnchorPoint = Vector2.new(0.5, 0), Position = UDim2.new(0.5, 0, 0, 16), Size = UDim2.fromOffset(430, 96), } self.rankCard = card New.padding(12).Parent = card self.currentIconHolder = New("Frame") { Name = "CurrentIcon", Parent = card, BackgroundTransparency = 1, Size = UDim2.fromOffset(68, 68), Position = UDim2.fromOffset(0, 2), } self.nextIconHolder = New("Frame") { Name = "NextIcon", Parent = card, BackgroundTransparency = 1, AnchorPoint = Vector2.new(1, 0), Position = UDim2.new(1, 0, 0, 8), Size = UDim2.fromOffset(56, 56), } local middle = New("Frame") { Name = "Middle", Parent = card, BackgroundTransparency = 1, Position = UDim2.fromOffset(78, 0), Size = UDim2.new(1, -78 - 64, 1, 0), } self.rankName = Components.label { Parent = middle, Name = "RankName", Text = "Unranked", Color = Theme.Color.Text, Font = Theme.Font.Display, TextSize = 20, Size = UDim2.new(1, 0, 0, 24), } self.rankRarity = Components.label { Parent = middle, Name = "Rarity", Text = "Clear a challenge to earn your first trophy", Color = Theme.Color.TextMuted, Font = Theme.Font.Medium, TextSize = 13, Position = UDim2.fromOffset(0, 24), Size = UDim2.new(1, 0, 0, 16), } self.rankBar = Components.progressBar { Parent = middle, Position = UDim2.new(0, 0, 0, 44), Size = UDim2.new(1, 0, 0, 12), } self.rankProgressLabel = Components.label { Parent = middle, Name = "Progress", Text = "0 / 0", Color = Theme.Color.TextMuted, Font = Theme.Font.Bold, TextSize = 12, Position = UDim2.new(0, 0, 0, 58), Size = UDim2.new(1, 0, 0, 14), XAlign = Enum.TextXAlignment.Right, } end function HUD:_buildChallengeBanner() local banner = Components.panel { Parent = self.root, Name = "ChallengeBanner", AnchorPoint = Vector2.new(0.5, 1), Position = UDim2.new(0.5, 0, 1, -22), Size = UDim2.fromOffset(330, 58), Color = Theme.Color.PanelRaised, StrokeColor = Theme.Color.Success, StrokeTransparency = 0.1, } banner.Visible = false self.challengeBanner = banner New.padding(10).Parent = banner self.challengeName = Components.label { Parent = banner, Name = "Name", Text = "", Color = Theme.Color.Text, Font = Theme.Font.Display, TextSize = 18, Size = UDim2.new(0.62, 0, 0, 22), } self.challengeReward = Components.label { Parent = banner, Name = "Reward", Text = "", Color = Theme.Color.Coin, Font = Theme.Font.Bold, TextSize = 13, Position = UDim2.fromOffset(0, 22), Size = UDim2.new(0.62, 0, 0, 16), } self.challengeTimer = Components.label { Parent = banner, Name = "Timer", Text = "0.0s", Color = Theme.Color.Success, Font = Theme.Font.Display, TextSize = 26, Size = UDim2.new(1, 0, 1, 0), XAlign = Enum.TextXAlignment.Right, } end function HUD:_buildButtons() local column = New("Frame") { Name = "Buttons", Parent = self.root, BackgroundTransparency = 1, AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -16, 0.5, 0), Size = UDim2.fromOffset(158, 160), New.list { Padding = UDim.new(0, 8), VerticalAlignment = Enum.VerticalAlignment.Center, HorizontalAlignment = Enum.HorizontalAlignment.Right, }, } self.buttonColumn = column self.rankButton = Components.button { Parent = column, Name = "RanksButton", Text = "Ranks", LayoutOrder = 1, Size = UDim2.fromOffset(158, 46), Color = Theme.Color.Accent, OnClick = function() self:_emit("Ranks") end, } table.insert(self.buttons, self.rankButton) if Config.Progression.RebirthEnabled then self.rebirthButton = Components.button { Parent = column, Name = "RebirthButton", Text = "Rebirth", LayoutOrder = 2, Size = UDim2.fromOffset(158, 46), Color = Theme.Color.AccentDeep, TextSize = 15, OnClick = function() self:_emit("Rebirth") end, } table.insert(self.buttons, self.rebirthButton) end self.settingsButton = Components.button { Parent = column, Name = "SettingsButton", Text = "Settings", LayoutOrder = 3, Size = UDim2.fromOffset(158, 46), Color = Theme.Color.PanelRaised, OnClick = function() self:_emit("Settings") end, } table.insert(self.buttons, self.settingsButton) end -------------------------------------------------------------------------------- -- Rendering -------------------------------------------------------------------------------- local function swapIcon(holder: Frame, definition, locked: boolean) holder:ClearAllChildren() if not definition then return nil end local icon = RankIcon.create(definition, { Locked = locked, Size = UDim2.fromScale(1, 1) }) icon.Parent = holder return icon end function HUD:render(profile) self.speedCounter:set(profile.Speed) self.trophyCounter:set(profile.Trophies) local walkSpeed = SpeedCurve.walkSpeed(profile.Speed, profile.Rebirths) local capped = SpeedCurve.isCapped(profile.Speed, profile.Rebirths) local walkText = if capped then string.format("%d studs/s (max)", math.floor(walkSpeed)) else string.format("%d studs/s", math.floor(walkSpeed)) if self.walkSpeedLabel.Text ~= walkText then self.walkSpeedLabel.Text = walkText end self.rows.Reward.set(Progression.getSpeedPerStep(profile)) self.rows.Distance.set(profile.Distance) self.rows.Steps.set(profile.Steps) self.rows.Coins.set(profile.Coins) self.rows.Rebirths.set(profile.Rebirths) if self.rebirthButton then local allowed, cost = Progression.canRebirth(profile) self.rebirthButton.setEnabled(allowed) self.rebirthButton.setText(if allowed then "Rebirth!" else `Rebirth @ {Format.abbreviate(cost)}`) end self:_renderRank(profile) end function HUD:_renderRank(profile) local alpha, earned, needed, current, upcoming = Ranks.getLadderProgress(profile.Trophies, profile.Ranks) local currentId = current and current.Id or nil if currentId ~= self.currentRankId then self.currentRankId = currentId swapIcon(self.currentIconHolder, current, false) if current then local rarity = Ranks.getRarity(current) self.rankName.Text = `{current.Name} Rank` self.rankRarity.Text = rarity.Name self.rankRarity.TextColor3 = rarity.Color self.rankBar.setColor(ColorSequence.new(rarity.Color, Theme.lighten(rarity.Color, 0.35))) else self.rankName.Text = "Unranked" self.rankRarity.Text = "Clear a challenge to earn your first trophy" self.rankRarity.TextColor3 = Theme.Color.TextMuted self.rankBar.setColor(Theme.SpeedGradient) end end local nextId = upcoming and upcoming.Id or nil if nextId ~= self.nextRankId then self.nextRankId = nextId swapIcon(self.nextIconHolder, upcoming, true) end self.rankBar.setAlpha(alpha) local progressText = if upcoming then `{Format.comma(earned)} / {Format.comma(needed)} trophies to {upcoming.Name}` else "Every rank unlocked" if self.rankProgressLabel.Text ~= progressText then self.rankProgressLabel.Text = progressText end end --- Flashes the speed number when a reward lands. function HUD:pulse() Motion.pop(self.speedLabel, 1.12, 0.4) end --- Flashes the trophy number when a course pays out. function HUD:pulseTrophies() Motion.pop(self.trophyLabel, 1.18, 0.45) end -------------------------------------------------------------------------------- -- Challenge banner -------------------------------------------------------------------------------- --- Shows or hides the live run banner. `id` is a challenge id, or nil to clear. function HUD:setChallenge(id: string?) local definition = if id then Challenges.get(id) else nil if not definition then self.challengeId = nil self.challengeStartedAt = nil if self.challengeBanner.Visible then self.challengeBanner.Visible = false end return end local difficulty = Challenges.getDifficulty(definition) self.challengeId = definition.Id self.challengeStartedAt = os.clock() self.challengeName.Text = definition.Name self.challengeReward.Text = `{difficulty.Name} · +{definition.Trophies} {definition.Trophies == 1 and "trophy" or "trophies"}` self.challengeTimer.Text = "0.0s" self.challengeTimer.TextColor3 = difficulty.Color self.challengeBanner.Visible = true end function HUD:_stepChallengeTimer(deltaTime: number) if not self.challengeStartedAt then return end -- 10 Hz: one decimal place cannot show more than that anyway. self.challengeTick += deltaTime if self.challengeTick < 0.1 then return end self.challengeTick = 0 local elapsed = os.clock() - self.challengeStartedAt -- The server expires a run at the same point. Clearing the banner locally -- means a player who wandered off is not left staring at a dead timer. if elapsed > Config.Challenges.RunTimeout then self:setChallenge(nil) return end self.challengeTimer.Text = string.format("%.1fs", elapsed) end -------------------------------------------------------------------------------- -- Layout -------------------------------------------------------------------------------- function HUD:setScale(scale: number) self.scale.Scale = scale end function HUD:setCompact(compact: boolean) if self.compact == compact then return end self.compact = compact self.statsPanel.Size = UDim2.fromOffset( if compact then PANEL_WIDTH_COMPACT else PANEL_WIDTH, if compact then PANEL_HEIGHT_COMPACT else PANEL_HEIGHT ) for _, name in { "Steps", "Coins", "Rebirths" } do self.rows[name].Instance.Visible = not compact end self.rankCard.Size = if compact then UDim2.fromOffset(330, 88) else UDim2.fromOffset(430, 96) self.rankProgressLabel.Visible = not compact self.challengeBanner.Size = if compact then UDim2.fromOffset(268, 52) else UDim2.fromOffset(330, 58) local buttonWidth = if compact then 122 else 158 for _, handle in self.buttons do handle.Instance.Size = UDim2.fromOffset(buttonWidth, if compact then 40 else 46) end self.buttonColumn.Size = UDim2.fromOffset(buttonWidth, 160) end function HUD:setVisible(visible: boolean) self.root.Visible = visible end -------------------------------------------------------------------------------- -- Events -------------------------------------------------------------------------------- function HUD:on(name: string, callback: () -> ()) self.callbacks[name] = callback end function HUD:_emit(name: string) local callback = self.callbacks[name] if callback then callback() end end --- Gamepad navigation entry point: the first thing the D-pad should land on. function HUD:getPrimarySelection(): GuiObject return self.rankButton.Instance end return HUD ]]> Motion (), snap: (self: Counter, value: number) -> (), get: (self: Counter) -> number, destroy: (self: Counter) -> (), } type CounterState = { current: number, target: number, stiffness: number, epsilon: number, apply: (number) -> (), alive: boolean, dirty: boolean, } local counters: { CounterState } = {} local connection: RBXScriptConnection? = nil local function step(deltaTime: number) local index = 1 while index <= #counters do local state = counters[index] if not state.alive then -- Swap-remove: order does not matter and it keeps removal O(1). counters[index] = counters[#counters] counters[#counters] = nil continue end if state.dirty then state.current = Util.damp(state.current, state.target, state.stiffness * Motion.speed, deltaTime) if math.abs(state.target - state.current) <= state.epsilon then state.current = state.target state.dirty = false end state.apply(state.current) end index += 1 end if #counters == 0 and connection then connection:Disconnect() connection = nil end end local function ensureRunning() if not connection then connection = RunService.PreRender:Connect(step) end end --- Creates a value that eases toward whatever you `set` it to. --- `apply` receives the smoothed value every frame while it is moving. function Motion.counter( apply: (number) -> (), options: { stiffness: number?, epsilon: number?, start: number? }? ): Counter local settings = options or {} local state: CounterState = { current = settings.start or 0, target = settings.start or 0, stiffness = settings.stiffness or Config.UI.NumberSmoothing, epsilon = settings.epsilon or 0.5, apply = apply, alive = true, dirty = false, } table.insert(counters, state) ensureRunning() apply(state.current) local counter = {} function counter:set(target: number) if state.target == target then return end state.target = target state.dirty = true ensureRunning() end function counter:snap(value: number) state.current = value state.target = value state.dirty = false state.apply(value) end function counter:get(): number return state.current end function counter:destroy() state.alive = false end return counter end --- Convenience wrapper: a counter that writes a formatted number into a label. function Motion.numberLabel(label: TextLabel, formatter: (number) -> string, stiffness: number?): Counter return Motion.counter(function(value) label.Text = formatter(value) end, { stiffness = stiffness or Config.UI.NumberSmoothing, epsilon = 0.5 }) end --- Convenience wrapper: a counter that drives a progress bar fill (0..1). function Motion.barFill(fill: GuiObject, stiffness: number?): Counter return Motion.counter(function(alpha) fill.Size = UDim2.fromScale(math.clamp(alpha, 0, 1), 1) end, { stiffness = stiffness or Config.UI.BarSmoothing, epsilon = 0.001 }) end return Motion ]]> New Notifications Config.UI.MaxNotifications do self:_dismiss(self.cards[1]) end self:_reflow() Sound.play(if definition then "Trophy" else "Click", 1, 0.3) task.delay(Config.UI.NotificationDuration, function() self:_dismiss(card) end) end function Notifications:setScale(scale: number) self.scale.Scale = scale end return Notifications ]]> RankIcon RankWindow = definition.RecommendedWalkSpeed entry.requirement.Text = `Needs about {definition.RecommendedWalkSpeed} studs/s · you are at {math.floor(walkSpeed)}` entry.requirement.TextColor3 = if ready then Theme.Color.Success else Theme.Color.Warning if record and record.Completions > 0 then entry.record.Text = `Cleared {Format.comma(record.Completions)}x · best {string.format("%.1fs", record.BestTime)}` else entry.record.Text = "Not cleared yet" end entry.status.Text = if ready then "READY" else "TOO SLOW" entry.status.TextColor3 = if ready then Theme.Color.Success else Theme.Color.Warning end end -------------------------------------------------------------------------------- -- Rendering -------------------------------------------------------------------------------- local function rewardLines(definition, ownedTitle: boolean, ownedTrail: boolean): { { text: string, color: Color3 } } local lines = {} local rewards = definition.Rewards if rewards.Coins then table.insert(lines, { text = `{Format.comma(rewards.Coins)} coins`, color = Theme.Color.Coin }) end if rewards.SpeedMultiplier then table.insert(lines, { text = `+{math.floor(rewards.SpeedMultiplier * 100 + 0.5)}% Speed per reward`, color = Theme.Color.Speed, }) end if rewards.Title then local title = Cosmetics.getTitle(rewards.Title) table.insert(lines, { text = `Title: {title and title.Name or rewards.Title}`, color = if ownedTitle then Theme.Color.Text else Theme.Color.TextDim, }) end if rewards.Trail then local trail = Cosmetics.getTrail(rewards.Trail) table.insert(lines, { text = `Trail: {trail and trail.Name or rewards.Trail}`, color = if ownedTrail then Theme.Color.Text else Theme.Color.TextDim, }) end return lines end function RankWindow:select(id: string) if self.selectedId == id then return end self.selectedId = id if self.profile then self:render(self.profile, true) end end --- What this window depends on. Speed is in it only because the challenges tab --- shows whether you are fast enough, and that is bucketed to a whole stud. local function renderSignature(profile, selectedId: string, tab: string): string local ranked = 0 for _ in profile.Ranks do ranked += 1 end local cleared = 0 for _, record in profile.Challenges do cleared += record.Completions end local titleCount = 0 for _ in profile.Titles do titleCount += 1 end local trailCount = 0 for _ in profile.Trails do trailCount += 1 end local walkSpeed = math.floor(SpeedCurve.walkSpeed(profile.Speed, profile.Rebirths)) return `{tab}|{selectedId}|{profile.Trophies}|{ranked}|{cleared}|{titleCount}|{trailCount}` .. `|{profile.EquippedTitle}|{profile.EquippedTrail}|{walkSpeed}` end function RankWindow:render(profile, force: boolean?) self.profile = profile local signature = renderSignature(profile, self.selectedId, self.tab) if signature == self.renderKey and not force then return end self.renderKey = signature local unlocked = 0 for _, definition in Ranks.List do local tile = self.tiles[definition.Id] local hasIt = profile.Ranks[definition.Id] ~= nil if hasIt then unlocked += 1 end if tile.owned ~= hasIt then tile.owned = hasIt tile.iconHolder:ClearAllChildren() local icon = RankIcon.create(definition, { Locked = not hasIt, Size = UDim2.fromScale(1, 1) }) icon.Parent = tile.iconHolder tile.name.TextColor3 = if hasIt then Theme.Color.Text else Theme.Color.TextDim tile.stroke.Transparency = if hasIt then 0.15 else 0.7 end local selected = definition.Id == self.selectedId tile.button.BackgroundColor3 = if selected then Theme.Color.PanelRaised else Theme.Color.Panel tile.stroke.Thickness = if selected then 2 else 1 end self.countLabel.Text = `{Format.comma(profile.Trophies)} trophies · {unlocked} / {#Ranks.List} ranks` self:_renderShowcase(profile) self:_renderChallenges(profile) end function RankWindow:_renderShowcase(profile) local definition = Ranks.get(self.selectedId) if not definition then return end local rarity = Ranks.getRarity(definition) local hasIt = profile.Ranks[definition.Id] ~= nil self.showcaseIcon:ClearAllChildren() local icon = RankIcon.create(definition, { Locked = not hasIt, Size = UDim2.fromScale(1, 1) }) icon.Parent = self.showcaseIcon self.showcaseName.Text = `{definition.Name} Rank` self.showcaseName.TextColor3 = if hasIt then Theme.Color.Text else Theme.Color.TextMuted self.showcaseRarity.Text = if hasIt then `{string.upper(rarity.Name)} · UNLOCKED` else `{string.upper(rarity.Name)} · {Format.comma(definition.Requirement)} TROPHIES` self.showcaseRarity.TextColor3 = rarity.Color self.showcaseDescription.Text = definition.Description local ownedTitle = definition.Rewards.Title ~= nil and profile.Titles[definition.Rewards.Title] == true local ownedTrail = definition.Rewards.Trail ~= nil and profile.Trails[definition.Rewards.Trail] == true self.rewardList:ClearAllChildren() New.list({ Padding = UDim.new(0, 4) }).Parent = self.rewardList for index, line in rewardLines(definition, ownedTitle, ownedTrail) do Components.label { Parent = self.rewardList, Name = `Reward{index}`, Text = `• {line.text}`, Color = line.color, Font = Theme.Font.Medium, TextSize = 14, Size = UDim2.new(1, 0, 0, 18), LayoutOrder = index, } end local titleId = definition.Rewards.Title if titleId then local equipped = profile.EquippedTitle == titleId self.equipTitleButton.Instance.Visible = true self.equipTitleButton.setEnabled(ownedTitle and not equipped) self.equipTitleButton.setText(if equipped then "Title equipped" else "Equip title") else self.equipTitleButton.Instance.Visible = false end local trailId = definition.Rewards.Trail if trailId then local equipped = profile.EquippedTrail == trailId self.equipTrailButton.Instance.Visible = true self.equipTrailButton.setEnabled(ownedTrail and not equipped) self.equipTrailButton.setText(if equipped then "Trail equipped" else "Equip trail") else self.equipTrailButton.Instance.Visible = false end end function RankWindow:_equip(kind: string) local definition = Ranks.get(self.selectedId) if not definition then return end local id = if kind == "Title" then definition.Rewards.Title else definition.Rewards.Trail if not id then return end local callback = self.callbacks.Equip if callback then callback(kind, id) end end -------------------------------------------------------------------------------- -- Window behaviour -------------------------------------------------------------------------------- function RankWindow:setOpen(open: boolean) if self.open == open then return end self.open = open if open then self.gui.Enabled = true self.panel.Position = UDim2.fromScale(0.5, 0.56) Motion.tween(self.backdrop, { BackgroundTransparency = 0.45 }, 0.22) Motion.tween(self.panel, { Position = UDim2.fromScale(0.5, 0.5) }, 0.3, Enum.EasingStyle.Back) Sound.play("Click", 1.15, 0.3) local callback = self.callbacks.Opened if callback then callback() end else Motion.tween(self.backdrop, { BackgroundTransparency = 1 }, 0.2) local slide = Motion.tween(self.panel, { Position = UDim2.fromScale(0.5, 0.56) }, 0.2) slide.Completed:Once(function() if not self.open then self.gui.Enabled = false end end) local callback = self.callbacks.Closed if callback then callback() end end end function RankWindow:isOpen(): boolean return self.open end function RankWindow:setScale(scale: number) self.scale.Scale = scale end function RankWindow:setCompact(compact: boolean) if self.compact == compact then return end self.compact = compact local layout = self.ranksBody:FindFirstChildOfClass("UIListLayout") if layout then layout.FillDirection = if compact then Enum.FillDirection.Vertical else Enum.FillDirection.Horizontal end if compact then self.panel.Size = UDim2.fromScale(0.94, 0.86) self.grid.Size = UDim2.new(1, 0, 0.52, -6) self.showcase.Size = UDim2.new(1, 0, 0.48, -6) else self.panel.Size = UDim2.fromScale(0.78, 0.74) self.grid.Size = UDim2.new(0.56, -6, 1, 0) self.showcase.Size = UDim2.new(0.44, -6, 1, 0) end end function RankWindow:on(name: string, callback) self.callbacks[name] = callback end --- Where gamepad focus should land when the window opens. function RankWindow:getPrimarySelection(): GuiObject if self.tab ~= "Ranks" then return self.tabButtons.Challenges.Instance end local tile = self.tiles[self.selectedId] return tile and tile.button or self.panel end return RankWindow ]]> SettingsWindow Sound Theme Workspace 196.2 false true 3 256 1024