-
Lighting
0.102
0.11
0.141
1.35
17.3
0
0
0
0.063
0.071
0.09
0.8
0.5
0.05
20
true
0.22
0.247
0.318
4
-
Atmosphere
0.71
0.741
0.804
0.416
0.447
0.545
0.32
0.15
1.4
0.15
-
Depth
0.1
22
90
0
-
Glow
0.5
24
1.6
-
Grade
-0.02
0.14
-0.1
0.957
0.973
1
-
Rays
0.12
0.85
-
ReplicatedFirst
-
Boot
-
Loading
0 then
pcall(function()
ContentProvider:PreloadAsync(queue)
end)
end
setTarget(0.8)
-- The real finish line: the character exists and the interface has booted.
subtitle.Text = "ENTERING"
local timeout = os.clock() + 20
while os.clock() < timeout do
-- `Layer_Boot` is what `UI/Core/Layer` names the dive sequence's
-- ScreenGui. Its existence is the signal that the interface is up and
-- there is something real to fade into.
if player.Character and player.PlayerGui:FindFirstChild("Layer_Boot") then
break
end
task.wait(0.1)
end
setTarget(1)
end)
local connection
connection = RunService.RenderStepped:Connect(function(dt)
-- Creeps forward even with no news, so a stalled connection still looks
-- alive. It can never reach the target on its own.
setTarget(math.min(progress + dt * 0.02, 0.5))
-- Chases hard once the finish line is real. The dive sequence starts as
-- soon as the interface boots and runs about eight seconds; easing gently
-- into the last few percent kept this opaque backdrop over the top of the
-- first two of them, so the game's signature opening played to nobody.
local speed = if target >= 1 then 9 else 3
progress += (target - progress) * math.min(dt * speed, 1)
fill.Size = UDim2.fromScale(progress, 1)
if progress > 0.995 then
connection:Disconnect()
-- Fades rather than cuts. Whatever is underneath — the dive sequence,
-- the title screen — is already running by now, so a cut would show a
-- frame of it mid-animation.
for _, object in { title, subtitle } do
TweenService:Create(object, TweenInfo.new(0.4), { TextTransparency = 1 }):Play()
end
TweenService:Create(track, TweenInfo.new(0.4), { BackgroundTransparency = 1 }):Play()
TweenService:Create(fill, TweenInfo.new(0.4), { BackgroundTransparency = 1 }):Play()
local out = TweenService:Create(backdrop, TweenInfo.new(0.7, Enum.EasingStyle.Quad), {
BackgroundTransparency = 1,
})
out:Play()
out.Completed:Wait()
gui:Destroy()
end
end)
]]>
-
ReplicatedStorage
-
Shared
-
Combat
-
Audio
duckUntil then
duckUntil = releaseAt
end
TweenService:Create(group, TweenInfo.new(Mix.Duck.attack), { Volume = bus.volume * depth }):Play()
if duckThread then
return
end
duckThread = task.spawn(function()
while os.clock() < duckUntil do
task.wait(0.05)
end
duckThread = nil
-- Re-read the bus volume rather than caching it: the player may have
-- moved the slider while the music was down, and coming back up to the
-- old level would silently undo their change.
TweenService:Create(group, TweenInfo.new(Mix.Duck.release), { Volume = bus.volume }):Play()
end)
end
--[[
Set a bus level, on this machine only.
Writes to `Mix.Buses` as well as to the group, because that table is what
the duck releases back to — setting only the group would work until the next
impact snapped it back to the old value.
]]
function Audio.setLevel(id: string, volume: number)
local bus = Mix.bus(id)
if not bus then
return
end
bus.volume = math.clamp(volume, 0, 1)
local group = groups[id]
if group and not (id == Mix.Duck.bus and duckThread) then
group.Volume = bus.volume
end
end
function Audio.level(id: string): number
local bus = Mix.bus(id)
return if bus then bus.volume else 1
end
return Audio
]]>
-
Vfx
-
Config
-
Appearance
-
Assist
= stage.failures then
found = stage
end
end
return found
end
--- Linear blend from weakest to strongest by strength.
local function blend(range, strength: number): number
return range.weakest + (range.strongest - range.weakest) * math.clamp(strength, 0, 1)
end
Assist.blend = blend
--- Everything the client and server need for one assisted attack. `stage`
--- decides what the client is allowed to draw.
function Assist.profile(strength: number, stage)
return {
strength = strength,
slow = blend(Assist.Slow, strength),
lead = blend(Assist.PromptLead, strength),
visibility = blend(Assist.Visibility, strength),
tier = if stage then stage.tier else 1,
ring = if stage then stage.ring else false,
prompt = if stage then stage.prompt else false,
}
end
return Assist
]]>
-
Bindings
-
Bunny
10.3 clears it
walk 16 studs/s -> 6.3 does not
So it is escapable, but only by spending sprint stamina — the same pool
you block and dodge with. That is the fight's central trade, not an
exception to it.
If you change `hang`, `fall`, `trackUntil` or `radius`, re-check
`SPRINT_SPEED * (hang * (1 - trackUntil) + fall) > radius`.
]]
leapAttack = {
name = "leapAttack",
--- A parry answers a blade coming at you; it does not answer four
--- hundred pounds of rabbit falling on your head. Guard still treats a
--- correctly-timed window as a block, so reading it is never wasted.
unparryable = true,
windup = 0.4,
commitAt = 0.82,
rise = 0.38,
--- Hangs above and slightly behind the camera. You lose sight of it.
hang = 0.3,
--- Fraction of the hang it is still re-aiming for. After this the
--- landing is locked and marked, and the hang becomes your head start.
trackUntil = 0.35,
fall = 0.2,
height = 46,
recover = 1.05,
--- The heaviest hit in the fight, and deliberately just under a fresh
--- character's 100 health. Surviving on 4 is the point; dying outright
--- is a different, worse lesson.
damage = 96,
radius = 8.5,
weight = 0.7,
},
spinSlash = {
name = "spinSlash",
windup = 0.44,
commitAt = 0.6,
hits = 3,
between = 0.24,
recover = 0.95,
damage = 31,
radius = 8.5,
weight = 0.65,
},
retreat = {
name = "retreat",
--- Not an attack: a disengage that buys it space and buys you nothing.
hops = 2,
recover = 0.2,
weight = 0.4,
},
}
--- Below `below` health it gets faster, jumps higher, waits less and feints
--- more. Phase 2 exists to make the last third of the fight the hard part.
Bunny.Frenzy = {
below = 0.35,
speed = 1.35,
height = 1.4,
--- Multiplier on rest and windup timings. Lower is faster.
timing = 0.68,
fakeBonus = 0.5,
}
--- Pause between actions, before frenzy scaling.
Bunny.Rest = {
min = 0.5,
max = 1.3,
--- Hops taken while waiting out the rest timer. It is always moving.
circleHops = 3,
}
--[[
BRAIN — utility scoring.
Each action's score is its base weight times a set of situational
multipliers. The brain picks from the top of the list with a little noise,
so it is legible without being deterministic. Values above 1 encourage,
below 1 discourage.
]]
Bunny.Utility = {
--- Applied when you are inside crowdedRange.
closeUp = { spinSlash = 2.6, retreat = 1.8, dashSlash = 0.35, leapAttack = 0.2, tripleDash = 0.3 },
--- Applied when you are beyond farRange.
farOff = { leapAttack = 2.4, tripleDash = 1.9, dashSlash = 1.2, spinSlash = 0.1, retreat = 0.2 },
--- You are low on stamina, so you cannot block or dodge much. Press.
staminaBelow = 0.35,
pressAdvantage = { dashSlash = 1.7, tripleDash = 1.6, spinSlash = 1.5, fakeAttack = 0.4, retreat = 0.2 },
--- You have parried it recently. Feint more; it has learned you will bite.
parryMemory = 3,
parryPunish = { fakeAttack = 3.0, dashSlash = 0.6, tripleDash = 0.8 },
--- You have been swinging a lot. Back off and make you chase.
aggressionWindow = 4,
aggressionThreshold = 5,
spacing = { retreat = 2.2, leapAttack = 1.6, fakeAttack = 1.4, spinSlash = 0.5 },
--- Never repeat the same action twice running unless forced.
repeatPenalty = 0.3,
--- Random jitter so identical situations don't always give identical picks.
noise = 0.25,
}
--- Shove distances are NOT here — they are `Parry.Shove` and `Parry.FailShove`,
--- because every enemy uses them and two copies drift.
Bunny.Guard = {
--- Damage multiplier while it is recovering from an attack.
punish = 1.5,
--- Damage multiplier while staggered by a parry.
counter = 2.5,
staggerTime = 1.8,
}
--- Boss intro cinematic beats, in seconds from the trigger.
Bunny.Intro = {
--- It keeps eating. You have to get close before it acknowledges you.
graze = 1.6,
--- Ambience drops out. Birds stop, wind dies.
silence = 0.8,
--- Head turns toward you.
turn = 1.1,
--- Eyes come up.
glare = 0.9,
--- Bar and title land, music starts.
reveal = 1.0,
total = 5.4,
}
return Bunny
]]>
-
Characters
-
Crafting
-
Encounters
-
Feel
-
Fishing
= fish.quality then
table.insert(pool, fish)
total += fish.weight
end
end
-- A carp is always in the pool, so this can never fail to return.
if total <= 0 then
return Fishing.Stock[1]
end
local pick = random:NextNumber() * total
for _, fish in pool do
pick -= fish.weight
if pick <= 0 then
return fish
end
end
return pool[#pool]
end
--- Grades a strike. `offset` is how far from the window's centre the press
--- landed, as a fraction of half the window.
function Fishing.grade(offset: number): (number, string)
local quality = math.clamp(1 - math.abs(offset), 0, 1)
local label = if quality >= 1 - Fishing.PerfectBand
then "PERFECT"
elseif quality >= 0.6 then "GOOD"
elseif quality >= 0.3 then "FAIR"
else "SCRAPPY"
return quality, label
end
return Fishing
]]>
-
Items
-
Mix
-
Parry
-
Progression
-
Scale
-
Skills
= slot.levelRequired
end
return Skills
]]>
-
Sky
0 then into / span else 0, 0, 1)
-- Smoothstep, so the light eases through a transition instead of ramping
-- linearly and making dawn look like a dimmer switch.
t = t * t * (3 - 2 * t)
local blended = {}
for key, value in before do
local target = (after :: any)[key]
if typeof(value) == "number" and typeof(target) == "number" then
blended[key] = lerpNumber(value, target, t)
elseif typeof(value) == "Color3" and typeof(target) == "Color3" then
blended[key] = value:Lerp(target, t)
else
blended[key] = value
end
end
blended.name = if t < 0.5 then before.name else after.name
return blended :: any
end
--- True while it is dark enough for torches, night creatures and Lycagon.
function Sky.isNight(hour: number): boolean
hour = hour % 24
return hour >= 19.5 or hour < 5.5
end
return Sky
]]>
-
Theme
-
Town
= 5 and hour < 17 then
return "day"
elseif hour >= 17 and hour < 20.5 then
return "dusk"
end
return "night"
end
return Town
]]>
-
Tutorial
-
World
0.85 then
return Enum.Material.Rock
elseif slope > 0.5 then
return Enum.Material.Ground
end
if here > 44 then
return Enum.Material.Slate
end
return Enum.Material.Grass
end
--- Too steep or too wet to stand a tree on.
function World.isPlantable(x: number, z: number): boolean
local here = World.groundHeight(x, z)
if here < World.WaterLevel + 3 then
return false
end
local dx = World.groundHeight(x + 6, z) - World.groundHeight(x - 6, z)
local dz = World.groundHeight(x, z + 6) - World.groundHeight(x, z - 6)
return math.sqrt(dx * dx + dz * dz) / 12 < 0.8
end
return World
]]>
-
Items
-
Weapons
-
Mobs
Model,
}
Mobs.Catalog = {
{
id = "vorpal_bunny",
name = "Vorpal Bunny",
subtitle = "Unique Scenario · the first one that kills you",
width = 9,
plateY = 5.4,
tone = "Unique",
build = require(script.VorpalBunny),
},
{
id = "goblin",
name = "Goblin",
subtitle = "Common · the first thing anyone kills",
width = 8,
plateY = 7.4,
tone = "Success",
build = require(script.Goblin),
},
{
id = "emul",
name = "Emul",
subtitle = "Companion · Rabbiteer",
width = 9,
plateY = 5.0,
tone = "Accent",
build = require(script.Emul),
},
{
id = "lycagon",
name = "Lycagon the Nightslayer",
subtitle = "Unique Scenario · seven forms, seven nights",
width = 15,
plateY = 9.6,
tone = "Unique",
build = require(script.Lycagon),
},
{
id = "setsuna",
name = "Setsuna the Puppeteer",
subtitle = "Unique Scenario · nothing she fights with is her own",
width = 11,
plateY = 15.0,
tone = "Cursed",
build = require(script.Setsuna),
},
{
id = "wethermon",
name = "Wethermon the Tombguard",
subtitle = "Unique Scenario · undefeated for four centuries",
width = 13,
plateY = 14.0,
tone = "Unique",
build = require(script.Wethermon),
},
} :: { Entry }
function Mobs.find(id: string): Entry?
for _, entry in Mobs.Catalog do
if entry.id == id then
return entry
end
end
return nil
end
--- Builds a creature at `origin`. Returns nil for an unknown id rather than
--- erroring, so a bad spawner name can't take the server down.
function Mobs.build(id: string, origin: CFrame): Model?
local entry = Mobs.find(id)
if not entry then
warn(`[Mobs] unknown creature "{id}"`)
return nil
end
return entry.build(origin)
end
return Mobs
]]>
-
Anim
-
Emul
-
Goblin
-
Lycagon
-
Net
-
Rig
-
Setsuna
-
VorpalBunny
-
Wethermon
-
Network
client. Boss payload table, or nil when the fight ends.
"BossState",
--- Server -> client. (amount: number)
"PlayerDamaged",
--- Server -> client. (amount: number, kind: string, worldPosition: Vector3)
"BossDamaged",
--- Server -> client. (encounterId: string, rewardXp: number)
"EncounterCleared",
--- Client -> server. (comboIndex: number)
"Attack",
--- Client -> server. (holding: boolean) -- guard raised or lowered.
"Block",
--- Client -> server. No arguments. Asks the server to open a parry window;
--- the server decides whether it may, and later whether anything landed
--- inside it. The client never asserts a successful parry.
"Parry",
--- Server -> client. (accepted: boolean, cooldown: number, window: number)
"ParryResult",
--- Server -> client. (kind, data?) -- landed a hit or absorbed one; drives
--- hitstop, camera shake, screen flash and knockback.
"Impact",
--- Server -> client. (item: table) -- something dropped for you.
"Loot",
--- Server -> client. (enemyId: string, rewardXp: number)
"EnemyDefeated",
--- Server -> client. (hour: number, isNight: boolean) -- a few times a
--- second; clients interpolate their own for anything finer.
"TimeOfDay",
--- Server -> client. (beat: string) -- boss intro cinematic beats.
"BossIntro",
--- Server -> client. (kind: string) -- training-yard progress the client
--- cannot observe on its own, e.g. a dummy actually taking a hit.
"TutorialHit",
--- Client -> server. (originId: string) -- routes the spawn point.
"OriginChosen",
--- Server -> client. (profile: table?) -- an assisted attack is inbound;
--- show the focus effect for profile.realLead seconds. nil clears it.
"ParryPrompt",
--- Client -> server. (mode: "off"|"adaptive"|"always")
"AssistMode",
--- Client -> server. (drillName: string?) -- asks the instructor to run a
--- live exercise, e.g. swinging at you so the parry lesson has something
--- to parry. nil stops whatever is running.
"TutorialDrill",
--- Client -> server. (staminaFraction: number) -- reported a few times a
--- second so the AI can tell when you're out of options. Cosmetic only.
"Vitals",
--- Server -> client. (blocked: number, parried: boolean)
"GuardResult",
--- Client -> server. (duration: number) -- dodge invulnerability.
"Invulnerable",
--- Client -> server. ({ name, race, style }) once creation finishes, so the
--- server can put the right weapon in your hands.
"CharacterChosen",
----------------------------------------------------------------------
-- Town
----------------------------------------------------------------------
--- Server -> client. (profile: table) -- gold, materials, items, quests,
--- kills, titles. Re-sent whole on every change; it's small, and a client
--- that can't drift is one fewer class of bug.
"Profile",
--- Server -> client. (questId: string, state: string, progress: number)
--- state is "accepted" | "progress" | "ready" | "done".
"QuestUpdate",
--- Client -> server. (npcId: string, action: string, arg: any) -- the one
--- channel for everything a townsperson can do: "talk", "accept",
--- "turnin", "buy", "sell", "rest", "heal", "close".
"Interact",
--- Server -> client. (payload: table?) -- open a conversation, or nil to
--- close it. Carries the speaker, their line, and the buttons to offer.
"Dialogue",
--- Server -> client. (payload: table?) -- open a shop, or nil to close.
"Shop",
--- Server -> client. (payload: table?) -- open the crafting bench, or nil.
"Craft",
--- Client -> server. ("start" | "leave") -- Colosseum run control.
"Arena",
--- Server -> client. (payload: table?) -- wave counter and banner, or nil
--- when the run is over and the HUD should clear.
"ArenaState",
--- Server -> client. ({state, ...}) -- "cast" | "bite" | "caught" |
--- "missed" | "early". Casting and striking both come back up the Interact
--- channel, since a jetty is just another Interactable.
"Fishing",
}
local Network = {}
local folder: Folder
if RunService:IsServer() then
folder = ReplicatedStorage:FindFirstChild(FOLDER_NAME)
if not folder then
folder = Instance.new("Folder")
folder.Name = FOLDER_NAME
folder.Parent = ReplicatedStorage
end
for _, name in EVENTS do
if not folder:FindFirstChild(name) then
local remote = Instance.new("RemoteEvent")
remote.Name = name
remote.Parent = folder
end
end
else
folder = ReplicatedStorage:WaitForChild(FOLDER_NAME)
end
for _, name in EVENTS do
Network[name] = folder:WaitForChild(name)
end
return Network
]]>
-
Util
-
Build
-
Create
:Connect
* string key otherwise -> property assignment
* numeric key -> child, parented to the new instance
* `Parent` is always applied LAST, after children and properties, so the
instance enters the DataModel fully formed (one reflow, not N).
]]
local function Create(className: string, spec: { [any]: any }?): any
local instance = Instance.new(className)
local props = spec or {}
local parent = nil
for key, value in props do
if key == "Parent" then
parent = value
continue
end
if type(key) == "number" then
value.Parent = instance
continue
end
local existing = (instance :: any)[key]
if typeof(existing) == "RBXScriptSignal" and type(value) == "function" then
existing:Connect(value)
else
(instance :: any)[key] = value
end
end
instance.Parent = parent
return instance
end
return Create
]]>
-
Motion
1.
--- Returns a cancel function.
function Motion.drive(duration: number, fn: (alpha: number) -> (), onDone: (() -> ())?)
local elapsed = 0
local connection
connection = RunService.RenderStepped:Connect(function(dt)
elapsed += dt
local alpha = math.clamp(elapsed / duration, 0, 1)
fn(alpha)
if alpha >= 1 then
connection:Disconnect()
if onDone then
onDone()
end
end
end)
return function()
if connection.Connected then
connection:Disconnect()
end
end
end
--- Frame-rate independent exponential smoothing.
--- `speed` is roughly "how many e-folds per second".
function Motion.damp(current: number, target: number, speed: number, dt: number): number
return target + (current - target) * math.exp(-speed * dt)
end
--------------------------------------------------------------------------------
-- Entrances
--------------------------------------------------------------------------------
--[[
ONE ENTRANCE, USED EVERYWHERE.
Panels animated, but everything inside them appeared fully formed the
instant the panel did — a tab switch was a hard cut from one wall of text to
another, which is the difference between an interface that was designed and
one that was assembled. These two functions are the whole fix, and they are
deliberately small: a short rise and a fade, nothing that could be mistaken
for a transition in its own right.
The rise is 8 pixels. That is not a lot on purpose — big travel reads as
sliding, which is a different and much more annoying effect, and at 8px the
eye registers direction without registering movement.
]]
local RISE = 8
--[[
One element arriving. `delay` is what `stagger` uses to sequence a list.
TWO THINGS THIS HAS TO BE CAREFUL ABOUT, both of which are easy to get
wrong and neither of which fails loudly:
1. Only touch properties the instance actually has. `TweenService:Create`
throws on an unknown property, so naming `TextTransparency` in a shared
props table takes out every Frame it is ever handed.
2. Restore what was there, never assume opaque. Rows in the controls panel
deliberately sit at partial transparency once their key has been used;
fading them all to 0 would silently undo that and re-light a list the
player had already learned their way out of.
]]
function Motion.enter(instance: GuiObject, delay: number?)
-- A layout owns its children's Position, so the rise would be overwritten
-- on the next layout pass and is skipped. The fade still carries it.
local parent = instance.Parent
local laidOut = parent
and (parent:FindFirstChildWhichIsA("UIListLayout") or parent:FindFirstChildWhichIsA("UIGridLayout"))
if not laidOut then
local settled = instance.Position
instance.Position = settled + UDim2.fromOffset(0, RISE)
Motion.to(instance, Theme.Time.Base, { Position = settled }, Theme.Ease.Enter, delay)
end
local fade = {}
local background = instance.BackgroundTransparency
if background < 1 then
instance.BackgroundTransparency = 1
fade.BackgroundTransparency = background
end
if instance:IsA("TextLabel") or instance:IsA("TextButton") or instance:IsA("TextBox") then
local text = instance.TextTransparency
if text < 1 then
instance.TextTransparency = 1
fade.TextTransparency = text
end
end
if instance:IsA("ImageLabel") or instance:IsA("ImageButton") then
local image = instance.ImageTransparency
if image < 1 then
instance.ImageTransparency = 1
fade.ImageTransparency = image
end
end
if next(fade) then
Motion.to(instance, Theme.Time.Base, fade, Theme.Ease.Exit, delay)
end
end
--[[
A list arriving, one element after another.
`step` is the gap between neighbours and is the only number that matters
here. Too small and it is a fade; too large and the player is waiting on the
interface, which is unforgivable. 25ms across a handful of rows lands the
whole list inside a fifth of a second while still reading as a sequence.
Capped rather than scaled: a forty-item inventory staggered at 25ms would
take a full second to finish drawing, so past `MAX_STAGGERED` everything
remaining arrives with the last staggered element. The eye cannot follow
more than a few in sequence anyway.
]]
local MAX_STAGGERED = 10
function Motion.stagger(children: { GuiObject }, step: number?)
local gap = step or 0.025
for index, child in children do
Motion.enter(child, math.min(index - 1, MAX_STAGGERED) * gap)
end
end
--- Direct children that are worth animating, in layout order. Skips the
--- non-visual helpers (`UIListLayout`, `UIPadding`, strokes) that would
--- otherwise be counted as rows and throw the timing out.
function Motion.rows(parent: Instance): { GuiObject }
local out = {}
for _, child in parent:GetChildren() do
if child:IsA("GuiObject") then
table.insert(out, child)
end
end
table.sort(out, function(a, b)
if a.LayoutOrder ~= b.LayoutOrder then
return a.LayoutOrder < b.LayoutOrder
end
return a.Name < b.Name
end)
return out
end
return Motion
]]>
-
Render
= Render.MIN_AXIS and volume >= Render.MIN_VOLUME
end
--- True if a part of this size would cast. Exposed so the rule can be checked
--- without building anything.
function Render.wouldCast(size: Vector3): boolean
return math.min(size.X, size.Y, size.Z) >= Render.MIN_AXIS and (size.X * size.Y * size.Z) >= Render.MIN_VOLUME
end
return Render
]]>
-
Signal
(),
}
function Signal.new()
return setmetatable({
_handlers = {} :: { [any]: boolean },
}, Signal)
end
function Signal:Connect(fn: (...any) -> ()): Connection
self._handlers[fn] = true
local connection
connection = {
Connected = true,
Disconnect = function()
if not connection.Connected then
return
end
connection.Connected = false
self._handlers[fn] = nil
end,
}
return connection
end
--- Fires at most once, then disconnects itself.
function Signal:Once(fn: (...any) -> ()): Connection
local connection
connection = self:Connect(function(...)
connection:Disconnect()
fn(...)
end)
return connection
end
function Signal:Fire(...: any)
-- Snapshot first: a handler is allowed to disconnect during dispatch.
local snapshot = {}
for fn in self._handlers do
table.insert(snapshot, fn)
end
for _, fn in snapshot do
task.spawn(fn, ...)
end
end
function Signal:DisconnectAll()
table.clear(self._handlers)
end
function Signal:Destroy()
self:DisconnectAll()
end
return Signal
]]>
-
Trove
(item: T): T
table.insert(self._items, item)
return item
end
--- Connects to a signal and tracks the connection in one step.
function Trove:connect(signal: any, fn: (...any) -> ())
return self:add(signal:Connect(fn))
end
local function cleanupItem(item: any)
local itemType = typeof(item)
if itemType == "Instance" then
item:Destroy()
elseif itemType == "RBXScriptConnection" then
item:Disconnect()
elseif itemType == "function" then
item()
elseif itemType == "table" then
if typeof(item.Disconnect) == "function" then
item:Disconnect()
elseif typeof(item.Destroy) == "function" then
item:Destroy()
elseif typeof(item.destroy) == "function" then
item:destroy()
end
end
end
--- Cleans everything but keeps the Trove usable.
function Trove:clean()
-- Reverse order so children are torn down before their parents.
for i = #self._items, 1, -1 do
cleanupItem(self._items[i])
end
table.clear(self._items)
end
Trove.Destroy = Trove.clean
Trove.destroy = Trove.clean
return Trove
]]>
-
World
-
Detail
-
Firstia
-
Foliage
-
ServerScriptService
-
Server
-
Avatar
0
-
Boss
-
Lycagon
0
= 0.6 and not locked then
locked = ctx.facing()
end
ctx.telegraph(true, locked ~= nil, locked or ctx.facing(), 46, 16)
end)
ctx.telegraph(false)
local hold = ctx.beginAssist()
if hold > 0 then
ctx.await(hold, "crouch")
end
local from = ctx.position()
local direction = locked or ctx.facing()
local target = from + direction * 42
target = V(target.X, ctx.groundAt(target.X, target.Z), target.Z)
ctx.audio("dash")
Vfx.speedLines(from + V(0, 4, 0), target + V(0, 4, 0), Color3.fromRGB(255, 112, 36))
ctx.leap(
target,
16,
0.42 * scale,
{ compress = "crouch", compressTime = 0.06, air = "leapRise", land = "leapFall" }
)
-- Lands on you. Parryable, but the reach means a bad read is
-- unanswerable — this is the attack that teaches spacing.
ctx.quake(15, 78)
ctx.await(0.34, "slashFollow")
ctx.await(0.78 * scale, "recover")
end
--- Three swipes, alternating sides. Each is its own parry.
function Actions.rend(ctx)
local scale = scaleFor(ctx.phase())
ctx.audio("screech")
ctx.await(0.5 * scale, "crouch", function(phase)
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
ctx.telegraph(true, phase >= 0.55, ctx.facing(), 20, 22)
end)
ctx.telegraph(false)
for index = 1, 3 do
local hold = ctx.beginAssist()
if hold > 0 then
ctx.await(hold, "crouch")
end
ctx.await(0.16 * scale, "dash", function()
local _, playerPosition = ctx.player()
if playerPosition then
ctx.setPosition(ctx.position() + ctx.facing() * 0.4)
end
end)
ctx.strike(16, 42)
Vfx.slash(ctx.position() + V(0, 5, 0), ctx.facing(), 14, Color3.fromRGB(255, 120, 60))
ctx.audio("slash")
if index < 3 then
ctx.await(0.26 * scale, "slashFollow")
end
end
ctx.await(0.9 * scale, "recover")
end
--[[
Howl. Unparryable on purpose — you cannot parry a sound. It is a pure
spacing check: get out of the ring or take it, and it exists so the fight
can never be won standing in one place tapping F.
]]
function Actions.howl(ctx)
local scale = scaleFor(ctx.phase())
ctx.await(0.9 * scale, "crouch", function(phase)
ctx.telegraph(true, phase >= 0.5, ctx.facing(), 0, 0)
if phase > 0.5 then
Vfx.ring(ctx.position() + V(0, 0.3, 0), 26 * phase, Color3.fromRGB(255, 150, 60), 0.2, 0.3)
end
end)
ctx.telegraph(false)
ctx.audio("screech")
ctx.quake(26, 66, true)
ctx.await(1.1 * scale, "recover")
end
--- Circles, looking for an angle. He is never standing still.
function Actions.stalk(ctx)
local scale = scaleFor(ctx.phase())
for _ = 1, 3 do
local _, playerPosition = ctx.player()
if not playerPosition then
return
end
local toPlayer = playerPosition - ctx.position()
local flat = V(toPlayer.X, 0, toPlayer.Z)
local tangent = V(-flat.Unit.Z, 0, flat.Unit.X) * (if math.random() < 0.5 then 1 else -1)
local radial = if flat.Magnitude > 34 then flat.Unit else -flat.Unit * 0.3
local step = (tangent * 0.8 + radial * 0.6)
local landing = ctx.position() + step.Unit * 22
landing = V(landing.X, ctx.groundAt(landing.X, landing.Z), landing.Z)
ctx.leap(landing, 7, 0.34 * scale, { compress = "crouch", compressTime = 0.07, air = "air", land = "land" })
ctx.face(playerPosition - ctx.position())
ctx.await(0.14, "observe")
end
end
function Actions.stagger(ctx, duration: number)
ctx.audio("screech")
ctx.await(duration, "stagger")
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
ctx.await(0.25, "observe")
end
--------------------------------------------------------------------------------
-- Decisions
--------------------------------------------------------------------------------
--[[
Simple, and different from the bunny on purpose. The bunny reads *you*;
Lycagon reads the *distance*. Far away he closes with a pounce, mid-range
he circles, close he rends, and the howl comes out when you have been
standing on top of him too long.
]]
local function choose(_ctx, signals)
local roll = math.random()
if signals.distance > 40 then
return if roll < 0.75 then "pounce" else "stalk"
elseif signals.distance < 16 then
if roll < 0.4 then
return "howl"
end
return if roll < 0.85 then "rend" else "stalk"
end
if signals.last == "stalk" then
return if roll < 0.55 then "pounce" else "rend"
end
return if roll < 0.4 then "stalk" elseif roll < 0.75 then "pounce" else "rend"
end
--------------------------------------------------------------------------------
Runtime.create({
id = "lycagon",
name = "Lycagon the Nightslayer",
title = "Unique Scenario",
mobId = "lycagon",
maxHealth = 4200,
phases = 7,
rewardXp = 1400,
respawn = 60,
arena = ARENA,
aggroRange = 58,
leash = 190,
punish = 1.5,
staggerTime = 2.0,
hitHeight = 5,
hurtboxBonus = 6,
knockbackScale = 1.4,
idleState = "observe",
dormantState = "observe",
--- The rule that defines him. Daylight and he simply is not a fight.
available = function()
return Sky.isNight(Lighting.ClockTime)
end,
animate = Anim.lycagon,
actions = Actions,
choose = choose,
onPhase = function(ctx, phase)
-- Each form announces itself. Seven of these across a fight is the
-- pacing: you always know you have made progress.
ctx.audio("screech")
Vfx.ring(ctx.position() + V(0, 0.3, 0), 30, Color3.fromRGB(255, 120, 40), 0.7, 0.4)
Vfx.leaves(ctx.position(), 14)
if phase >= 5 then
Vfx.parryBurst(ctx.position() + V(0, 6, 0))
end
end,
})
print(`[Lycagon] waiting at {ARENA} — nights only`)
]]>
-
Runtime
rootOffset, parts, scale, rate
actions { [name] = function(ctx, scale) }
choose (ctx, signals) -> action name
punish damage multiplier while recovering
staggerTime base parry stagger
onDefeated optional
available optional () -> boolean; false keeps it dormant
]]
function Runtime.create(spec)
local boss = {
spec = spec,
model = nil,
rig = nil,
telegraph = nil,
health = spec.maxHealth,
position = spec.arena,
facing = V(0, 0, -1),
lookYaw = 0,
animState = "idle",
animPhase = 0,
action = nil,
aborted = false,
lastAction = nil,
pendingStagger = false,
staggerFor = spec.staggerTime,
engaged = false,
hitstopUntil = 0,
knockback = V(0, 0, 0),
phase = 1,
attackReadyAt = {},
}
----------------------------------------------------------------------------
--[[
Where the boss's feet go.
Defaults to the generated terrain, but a boss can declare a flat
`floorY` instead — which is what an indoor encounter needs. Wethermon
stands 26 studs below the surface in his own hall; grounding him on the
terrain above would leave him floating inside the ceiling of the room
built for him.
]]
local function groundAt(x: number, z: number): number
if spec.floorY then
return spec.floorY
end
return World.groundHeight(x, z)
end
local function nearestPlayer(): (Player?, Vector3?, Vector3?)
local best, bestDistance = nil, math.huge
for _, player in Players:GetPlayers() do
local root = rootOf(player)
if root then
local distance = (root.Position - boss.position).Magnitude
if distance < bestDistance then
best, bestDistance = player, distance
end
end
end
if not best then
return nil, nil, nil
end
local root = rootOf(best)
return best, root and root.Position, root and root.CFrame.LookVector
end
local function broadcastState()
local payload = if boss.engaged
then {
name = spec.name,
title = spec.title,
health = boss.health,
maxHealth = spec.maxHealth,
phase = boss.phase,
maxPhase = spec.phases,
unique = true,
}
else nil
for _, player in Players:GetPlayers() do
Network.BossState:FireClient(player, payload)
end
end
local function updateTelegraph(
visible: boolean,
committed: boolean?,
direction: Vector3?,
length: number?,
width: number?
)
if not boss.telegraph then
return
end
if not visible then
boss.telegraph.Transparency = 1
return
end
local span = math.max(length or 0, 6)
local dir = direction or boss.facing
local mid = boss.position + dir * (span / 2)
boss.telegraph.Size = V(width or 12, 0.14, span)
boss.telegraph.CFrame = CFrame.lookAt(V(mid.X, groundAt(mid.X, mid.Z) + 0.18, mid.Z), mid + dir)
boss.telegraph.Transparency = if committed then 0.2 else 0.78
boss.telegraph.Color = if committed then Theme.Color.Health else Theme.Color.StaminaEmpty
end
----------------------------------------------------------------------------
-- Context handed to actions
----------------------------------------------------------------------------
local ctx = {}
ctx.groundAt = groundAt
ctx.vfx = function()
return Vfx
end
function ctx.position()
return boss.position
end
function ctx.setPosition(value: Vector3)
boss.position = value
end
function ctx.facing()
return boss.facing
end
function ctx.face(direction: Vector3)
boss.facing = flatten(direction)
end
function ctx.player()
return nearestPlayer()
end
function ctx.health()
return boss.health / spec.maxHealth
end
function ctx.phase()
return boss.phase
end
function ctx.audio(name: string)
Audio.playAt(name, boss.position)
end
function ctx.audioAt(name: string, at: Vector3)
Audio.playAt(name, at)
end
function ctx.telegraph(visible, committed, direction, length, width)
updateTelegraph(visible, committed, direction, length, width)
end
function ctx.rig()
return boss.rig
end
--- Opens an assisted approach, returning how long to hold before striking.
function ctx.beginAssist(): number
local player = nearestPlayer()
if not player then
return 0
end
local profile = Assist.plan(player)
if not profile then
return 0
end
Assist.announce(player, profile)
return profile.impactDelay
end
function ctx.await(duration: number, stateName: string, onUpdate)
boss.animState = stateName
local elapsed = 0
repeat
local dt = coroutine.yield()
if boss.aborted then
error(ABORT)
end
elapsed += dt
boss.animPhase = if duration > 0 then math.clamp(elapsed / duration, 0, 1) else 1
if onUpdate then
onUpdate(boss.animPhase, dt)
end
until elapsed >= duration
end
--- Travels an arc to a landing point, with the usual four beats.
function ctx.leap(target: Vector3, height: number, airTime: number, states)
local from = boss.position
states = states or {}
ctx.await(states.compressTime or 0.1, states.compress or "compress")
ctx.audioAt("hop", from)
Vfx.dust(from, 0.9)
ctx.await(airTime, states.air or "air", function(phase)
local ground = from:Lerp(target, phase)
boss.position = ground + V(0, math.sin(phase * math.pi) * height, 0)
end)
boss.position = target
Vfx.landing(target, states.impact or 1.2)
ctx.audioAt("heavyLand", target)
ctx.await(states.landTime or 0.14, states.land or "land")
end
--[[
Hits the player if in range. `unparryable` attacks must be dodged —
every boss should have at least one, or the fight collapses into
standing still and pressing F on rhythm.
]]
function ctx.strike(radius: number, damage: number, unparryable: boolean?): boolean
local player, playerPosition = nearestPlayer()
if not (player and playerPosition) then
return false
end
local flat = V(playerPosition.X - boss.position.X, 0, playerPosition.Z - boss.position.Z)
if flat.Magnitude > radius then
return false
end
local outcome, staggerScale = Guard.resolve(player, {
damage = damage,
from = boss.position,
unparryable = unparryable,
})
if not unparryable then
Assist.finish(player, outcome == "parried")
end
if outcome == "dodged" then
return false
end
if outcome == "parried" then
boss.aborted = true
boss.pendingStagger = true
boss.staggerFor = spec.staggerTime * (if staggerScale > 0 then staggerScale else 1)
boss.hitstopUntil = os.clock() + Encounters.Hitstop.parry
boss.knockback = -boss.facing * Parry.Shove
updateTelegraph(false)
Vfx.leaves(boss.position, 8)
for _, other in Players:GetPlayers() do
Network.Impact:FireClient(other, "parry", { position = boss.position })
end
end
return true
end
--- A radial slam: hits everything inside `radius`, with a ring to match.
function ctx.quake(radius: number, damage: number, unparryable: boolean?)
Vfx.ring(boss.position + V(0, 0.2, 0), radius, Theme.Color.Danger, 0.45, 0.4)
Vfx.landing(boss.position, 2.2)
Vfx.leaves(boss.position, 16)
ctx.audio("heavyLand")
ctx.strike(radius, damage, unparryable)
end
----------------------------------------------------------------------------
local function startAction(fn, ...)
boss.aborted = false
local args = table.pack(...)
boss.action = coroutine.create(function()
fn(ctx, table.unpack(args, 1, args.n))
end)
end
local function spawn()
if boss.model then
boss.model:Destroy()
end
if boss.telegraph then
boss.telegraph:Destroy()
end
local arena = spec.arena
boss.position = V(arena.X, groundAt(arena.X, arena.Z), arena.Z)
local model = Mobs.build(spec.mobId, CFrame.new(boss.position))
if not model then
warn(`[Boss] could not build {spec.mobId}`)
return
end
model.Name = spec.name
model.Parent = folder
boss.model = model
boss.rig = Rig.bind(model)
Net.setRig(model, spec.animName or spec.mobId or spec.id)
boss.telegraph = Create("Part", {
Name = "Telegraph",
Anchored = true,
CanCollide = false,
CanQuery = false,
Size = V(12, 0.14, 1),
Color = Theme.Color.Health,
Material = Enum.Material.Neon,
Transparency = 1,
Parent = folder,
})
boss.health = spec.maxHealth
boss.phase = 1
boss.engaged = false
boss.action = nil
boss.lastAction = nil
-- Lets a boss tear down anything it spawned. Without this, a leash or a
-- respawn leaves its minions alive and hunting an empty arena.
if spec.onReset then
spec.onReset(boss)
end
broadcastState()
end
local function defeated()
boss.engaged = false
boss.action = nil
boss.aborted = true
updateTelegraph(false)
Audio.stopMusic()
Audio.playAt("defeat", boss.position)
Vfx.parryBurst(boss.position + V(0, 4, 0))
Vfx.leaves(boss.position, 26)
for _, player in Players:GetPlayers() do
Network.EncounterCleared:FireClient(player, spec.id, spec.rewardXp)
Rewards.grant(player, spec.mobId or spec.id, boss.position)
end
broadcastState()
local corpse = boss.model
boss.model, boss.rig = nil, nil
if corpse then
task.spawn(function()
for _ = 1, 40 do
if not corpse.Parent then
return
end
corpse:PivotTo(corpse:GetPivot() * CFrame.new(0, -0.14, 0))
task.wait(0.03)
end
corpse:Destroy()
end)
end
if spec.onDefeated then
spec.onDefeated()
end
task.delay(spec.respawn or 40, spawn)
end
----------------------------------------------------------------------------
RunService.Heartbeat:Connect(function(dt)
if not (boss.model and boss.rig) then
return
end
if os.clock() < boss.hitstopUntil then
return
end
if boss.knockback.Magnitude > 0.1 then
boss.position += boss.knockback * dt
boss.position = V(boss.position.X, groundAt(boss.position.X, boss.position.Z), boss.position.Z)
boss.knockback = boss.knockback:Lerp(V(0, 0, 0), math.min(dt * 7, 1))
end
local player, playerPosition = nearestPlayer()
local distance = if playerPosition then (playerPosition - boss.position).Magnitude else math.huge
-- Phase, derived from health so it can never disagree with the bar.
local wanted = math.clamp(spec.phases - math.floor(boss.health / spec.maxHealth * spec.phases), 1, spec.phases)
if wanted ~= boss.phase then
boss.phase = wanted
broadcastState()
-- The pulse under the fight quickens with each phase.
Audio.setIntensity(wanted)
if spec.onPhase then
spec.onPhase(ctx, wanted)
end
end
if boss.engaged and distance > spec.leash then
boss.engaged = false
boss.health = spec.maxHealth
boss.action = nil
updateTelegraph(false)
Audio.stopMusic()
broadcastState()
end
if boss.action then
if coroutine.status(boss.action) == "suspended" then
local ok, err = coroutine.resume(boss.action, dt)
if not ok and err ~= ABORT then
warn(`[Boss:{spec.id}] {err}`)
end
if not ok then
boss.action = nil
end
end
if boss.action and coroutine.status(boss.action) == "dead" then
boss.action = nil
end
end
local dormant = spec.available and not spec.available()
if not boss.action and boss.health > 0 then
if boss.pendingStagger then
boss.pendingStagger = false
boss.lastAction = nil
startAction(spec.actions.stagger or function(c, d)
c.await(d, "stagger")
end, boss.staggerFor)
elseif dormant then
boss.animState = spec.dormantState or "idle"
if boss.engaged then
boss.engaged = false
broadcastState()
end
elseif player and distance <= spec.aggroRange then
if not boss.engaged then
boss.engaged = true
broadcastState()
Audio.startMusic()
if spec.onEngage then
startAction(spec.onEngage)
end
else
local choice = spec.choose(ctx, {
distance = distance,
health = boss.health / spec.maxHealth,
phase = boss.phase,
last = boss.lastAction,
})
boss.lastAction = choice
local run = spec.actions[choice]
if run then
startAction(run)
end
end
else
boss.animState = spec.idleState or "idle"
end
end
if playerPosition then
local toPlayer = flatten(playerPosition - boss.position)
local cross = boss.facing.X * toPlayer.Z - boss.facing.Z * toPlayer.X
boss.lookYaw = math.deg(math.atan2(cross, math.clamp(boss.facing:Dot(toPlayer), -1, 1)))
end
--[[
Publish, don't pose.
The client runs `spec.animate` itself against these attributes and
interpolates between them, which is the only way to get smooth
motion out of anchored parts — see Mobs/Net. The server keeps
`boss.position` as the truth every hitbox is measured against.
]]
Net.publish(
boss.model,
CFrame.lookAt(boss.position, boss.position + boss.facing),
boss.animState,
boss.animPhase,
{ health = boss.health / spec.maxHealth, phase = boss.phase }
)
end)
----------------------------------------------------------------------------
-- Player damage
----------------------------------------------------------------------------
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" or not boss.model or boss.health <= 0 or not boss.engaged then
return
end
if Guard.inRecovery(player) then
return
end
local now = os.clock()
local step = Encounters.comboStep(comboIndex)
if boss.attackReadyAt[player] and now < boss.attackReadyAt[player] then
return
end
boss.attackReadyAt[player] = now + (step.windup + step.active) * 0.85
local root = rootOf(player)
if not root then
return
end
local toBoss = boss.position - root.Position
local flat = V(toBoss.X, 0, toBoss.Z)
if flat.Magnitude > Encounters.PlayerAttack.range + (spec.hurtboxBonus or 0) then
return
end
local look = flatten(root.CFrame.LookVector)
if math.deg(math.acos(math.clamp(look:Dot(flatten(flat)), -1, 1))) > Encounters.PlayerAttack.arc then
return
end
local multiplier = if boss.animState == "stagger"
then Parry.CounterMultiplier
elseif string.find(boss.animState, "recover") then spec.punish
else 1
local crit = math.random() < Encounters.PlayerAttack.critChance
--[[
Optional per-boss damage scaling.
A boss can be conditionally armoured — Setsuna takes 15% while any
puppet of hers is still standing, which is how "kill the adds
first" gets *taught* rather than written in a tooltip. Returning
below 1 here is a strong statement and should always come with a
visible reason on screen.
]]
local scale = if spec.damageScale then spec.damageScale(boss) else 1
local dealt =
math.floor(step.damage * multiplier * scale * (if crit then Encounters.PlayerAttack.critMultiplier else 1))
-- Never round a real hit down to nothing: a swing that connects has to
-- show a number, or the player concludes the game is broken.
dealt = math.max(dealt, 1)
boss.health = math.max(boss.health - dealt, 0)
boss.knockback = flatten(boss.position - root.Position) * step.knockback * (spec.knockbackScale or 3)
-- An armoured hit never reads as heavy, whatever the swing was.
local heavy = (step.knockback >= 30 or multiplier > 1) and scale >= 1
boss.hitstopUntil = now + (if heavy then Encounters.Hitstop.heavy else Encounters.Hitstop.light)
local at = boss.position + V(0, spec.hitHeight or 3, 0)
Vfx.sparks(at, if heavy then 26 else 12, Color3.fromRGB(255, 214, 160))
Vfx.slash(at, look, if heavy then 8 else 5.5, Color3.fromRGB(255, 236, 200))
Audio.playAt(if heavy then "hitHeavy" else "hitLight", boss.position)
Network.BossDamaged:FireClient(player, dealt, if crit or multiplier > 1 then "crit" else "normal", at)
Network.Impact:FireClient(player, if heavy then "heavy" else "light")
broadcastState()
if boss.health <= 0 then
defeated()
end
end)
Players.PlayerRemoving:Connect(function(player)
boss.attackReadyAt[player] = nil
end)
spawn()
return boss
end
return Runtime
]]>
-
Setsuna
0
0.1 then
entry.facing = entry.facing:Lerp(flat.Unit, math.clamp(dt * 5, 0, 1))
end
if entry.state == "close" then
if distance > 8.5 then
entry.position += flat.Unit * 11 * dt
entry.position =
V(entry.position.X, World.groundHeight(entry.position.X, entry.position.Z), entry.position.Z)
elseif entry.timer <= 0 then
entry.state = "telegraph"
entry.timer = 0.7
Vfx.closingRing(entry.position + V(0, 0.3, 0), 9, VIOLET, 0.7)
Audio.playAt("growl", entry.position)
end
elseif entry.state == "telegraph" and entry.timer <= 0 then
entry.state = "recover"
entry.timer = 1.15
Audio.playAt("slash", entry.position)
Vfx.slash(entry.position + V(0, 4, 0), entry.facing, 5, VIOLET)
if distance <= 10 then
Guard.resolve(player, { damage = entry.damage, from = entry.position })
end
elseif entry.state == "recover" and entry.timer <= 0 then
entry.state = "close"
end
-- Puppets hang: they sway on their thread and never quite settle.
entry.phase += dt * (if entry.state == "close" then 6 else 2.4)
local sway = math.sin(entry.phase) * 0.09
local lunge = if entry.state == "telegraph" then -0.6 else 0
Net.publish(
entry.model,
CFrame.lookAt(entry.position, entry.position + entry.facing)
* CFrame.Angles(0, 0, sway)
* CFrame.new(0, math.abs(math.sin(entry.phase * 0.5)) * 0.2, lunge),
entry.state,
entry.phase,
nil
)
end
--------------------------------------------------------------------------------
-- Her own actions
--------------------------------------------------------------------------------
local Actions = {}
--- Thread lash. Long, thin, parryable — her only clean tell.
function Actions.lash(ctx)
local scale = 1 - (ctx.phase() - 1) * 0.07
ctx.telegraph(true, false, ctx.facing(), 34, 6)
-- windRush, not "swoosh": that is the source file, not a declared cue.
ctx.audio("windRush")
ctx.await(0.62 * scale, "windup", function() end)
ctx.telegraph(true, true, ctx.facing(), 34, 6)
ctx.audio("slash")
Vfx.slash(ctx.position() + V(0, 7, 0), ctx.facing(), 12, THREAD)
ctx.strike(15, 78)
ctx.await(0.85 * scale, "recover", function() end)
ctx.telegraph(false)
end
--- Marionette pull: unparryable, and it drags you into whatever is waiting.
function Actions.pull(ctx)
ctx.telegraph(true, false, ctx.facing(), 40, 12)
ctx.audio("growl")
Vfx.ring(ctx.position() + V(0, 0.3, 0), 40, VIOLET, 0.8, 0.35)
ctx.await(0.9, "windup", function() end)
ctx.audio("screech")
-- Unparryable: the Wethermon already taught that some things must simply
-- be avoided, so this reuses a lesson rather than adding one.
ctx.quake(40, 62, true)
Vfx.parryBurst(ctx.position() + V(0, 6, 0))
ctx.await(1.4, "recover", function() end)
ctx.telegraph(false)
end
--- Raises a wave. She does nothing else while they stand.
function Actions.raise(ctx)
ctx.audio("screech")
Vfx.ring(ctx.position() + V(0, 0.3, 0), 30, VIOLET, 1.0, 0.4)
ctx.await(1.0, "windup", function() end)
waveIndex += 1
local phase = ctx.phase()
local count = WAVE[math.clamp(phase, 1, #WAVE)]
raiseWave(count, 150 + phase * 40, 22 + phase * 6)
ctx.await(0.8, "recover", function() end)
end
--- The open window. She hangs still and takes everything.
function Actions.slack(ctx)
ctx.audio("breath")
ctx.await(math.max(slackUntil - os.clock(), 0.5), "stagger", function() end)
end
function Actions.stagger(ctx)
ctx.audio("hurt")
ctx.await(2.2, "stagger", function() end)
end
--------------------------------------------------------------------------------
local function choose(_ctx, signals)
-- Threads slack: she is helpless and the fight pauses on purpose.
if os.clock() < slackUntil then
return "slack"
end
-- Nothing standing: put something up before doing anything else.
if #puppets == 0 then
return "raise"
end
local roll = math.random()
if signals.distance > 26 or roll < 0.34 then
return "pull"
end
return "lash"
end
--------------------------------------------------------------------------------
Runtime.create({
id = "setsuna",
name = "Setsuna the Puppeteer",
title = "Unique Scenario",
mobId = "setsuna",
maxHealth = 5200,
phases = 4,
rewardXp = 2400,
respawn = 75,
arena = ARENA,
aggroRange = 52,
leash = 170,
punish = 1.4,
staggerTime = 2.2,
hitHeight = 8,
hurtboxBonus = 3,
--- She hangs. Nothing moves her.
knockbackScale = 0.1,
idleState = "idle",
animate = Anim.setsuna,
actions = Actions,
choose = choose,
--- Barely damageable while anything she is holding is still standing.
damageScale = function()
return if #puppets > 0 then SHIELDED else 1
end,
onPhase = function(ctx, phase)
ctx.audio("screech")
Vfx.parryBurst(ctx.position() + V(0, 9, 0))
Vfx.ring(ctx.position() + V(0, 0.3, 0), 36, VIOLET, 1.0, 0.4)
-- Every phase she cuts the current wave loose and puts up a bigger one.
clearPuppets()
waveIndex = phase - 1
end,
onReset = function()
clearPuppets()
end,
})
--------------------------------------------------------------------------------
local function build()
local existing = Workspace:FindFirstChild("SetsunaPuppets")
if existing then
existing:Destroy()
end
folder = Create("Folder", { Name = "SetsunaPuppets", Parent = Workspace })
end
build()
--------------------------------------------------------------------------------
-- Damage into the puppets
--------------------------------------------------------------------------------
--[[
Puppets are hit through the same Attack remote as everything else, and a
swing picks the single nearest one. Cleave would defeat the entire lesson:
if one swing clears the wave, there is no priority decision to make.
]]
local Encounters = require(ReplicatedStorage.Shared.Config.Encounters)
local Network = require(ReplicatedStorage.Shared.Network)
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" or #puppets == 0 then
return
end
local root = rootOf(player)
if not root then
return
end
local step = Encounters.comboStep(comboIndex)
local best, bestIndex, bestDistance = nil, nil, Encounters.PlayerAttack.range
for index, entry in puppets do
local distance = (entry.position - root.Position).Magnitude
if distance < bestDistance then
best, bestIndex, bestDistance = entry, index, distance
end
end
if not best then
return
end
best.health -= step.damage
local at = best.position + V(0, 5, 0)
Vfx.sparks(at, 8, THREAD)
Audio.playAt("hitLight", at)
Network.BossDamaged:FireClient(player, step.damage, "normal", at)
if best.health <= 0 then
dropPuppet(bestIndex)
end
end)
RunService.Heartbeat:Connect(function(dt)
if #puppets == 0 then
return
end
-- Puppets only act while someone is here to act at.
local target
for _, player in Players:GetPlayers() do
if rootOf(player) then
target = player
break
end
end
if not target then
clearPuppets()
return
end
for index = #puppets, 1, -1 do
if puppets[index].health <= 0 then
dropPuppet(index)
else
stepPuppet(puppets[index], dt, target)
end
end
end)
Players.PlayerRemoving:Connect(function()
if #Players:GetPlayers() <= 1 then
clearPuppets()
end
end)
print(`[Setsuna] hanging at {ARENA}`)
]]>
-
Wethermon
0
= 0.7, ctx.facing(), 22, 30)
end)
ctx.telegraph(false)
local hold = ctx.beginAssist()
if hold > 0 then
ctx.await(hold, "windup")
end
ctx.await(0.22, "sweep", function()
ctx.setPosition(ctx.position() + ctx.facing() * 0.3)
end)
ctx.strike(17, 74)
Vfx.slash(ctx.position() + V(0, 6, 0), ctx.facing(), 20, TEAL)
ctx.audio("slash")
-- Deliberately long and inviting. The next thing he does is not.
ctx.await(1.35, "recover")
end
--[[
Overhead slam. Unparryable.
Tracks you through the windup, commits late, and lands in a circle. This is
the attack that teaches a parry-first player that the button is not always
the answer.
]]
function Actions.slam(ctx)
local landing = ctx.position()
ctx.audio("growl")
ctx.await(1.15, "raise", function(phase)
local _, playerPosition = ctx.player()
if playerPosition and phase < 0.78 then
landing = V(playerPosition.X, ctx.groundAt(playerPosition.X, playerPosition.Z), playerPosition.Z)
ctx.face(playerPosition - ctx.position())
end
-- Amber, not red: this one is a move-out-of-the-way, not a meet-it.
Vfx.ring(landing + V(0, 0.25, 0), 15 * (1 - phase * 0.75), Color3.fromRGB(255, 170, 70), 0.18, 0.32)
end)
ctx.await(0.24, "slam", function(phase)
ctx.setPosition(ctx.position():Lerp(landing, phase * 0.55))
end)
ctx.quake(15, 96, true)
ctx.await(1.5, "recover")
end
--- Radial quake, also unparryable. Punishes standing anywhere near him.
function Actions.quake(ctx)
ctx.await(1.0, "raise", function(phase)
Vfx.ring(ctx.position() + V(0, 0.25, 0), 30 * phase, Color3.fromRGB(255, 170, 70), 0.2, 0.35)
end)
ctx.audio("heavyLand")
ctx.quake(30, 68, true)
-- Pillars of light where the ground broke. Arena interaction, and it marks
-- where not to stand for the next few seconds.
for index = 1, 6 do
local angle = (index / 6) * math.pi * 2
local at = ctx.position() + V(math.cos(angle) * 18, 0, math.sin(angle) * 18)
Vfx.ring(V(at.X, ctx.groundAt(at.X, at.Z) + 0.2, at.Z), 7, TEAL, 0.8, 0.25)
end
ctx.await(1.6, "recover")
end
--- Closes the gap. Slow, loud, and impossible to miss coming.
function Actions.advance(ctx)
for _ = 1, 3 do
local _, playerPosition = ctx.player()
if not playerPosition then
return
end
ctx.face(playerPosition - ctx.position())
ctx.await(0.5, "step", function(phase)
local step = ctx.facing() * 9 * (1 / 60)
ctx.setPosition(ctx.position() + step)
if phase > 0.9 then
Vfx.dust(ctx.position(), 0.8)
end
end)
ctx.audio("heavyLand")
end
end
function Actions.stagger(ctx, duration: number)
-- Even staggered he does not fall. He kneels.
ctx.audio("blocked")
Vfx.sparks(ctx.position() + V(0, 6, 0), 30, TEAL)
ctx.await(duration, "stagger")
ctx.await(0.35, "idle")
end
--------------------------------------------------------------------------------
--[[
He does not improvise. The pattern is: close if far, sweep if in reach,
and punish anyone who overstayed the sweep's recovery with a slam.
Phase 2 adds the quake; phase 3 chains slams. Nothing here is random enough
to be unfair, which is the compliment the fight is paying you — it is
entirely learnable, and losing is entirely your fault.
]]
local function choose(_ctx, signals)
local roll = math.random()
if signals.distance > 26 then
return if roll < 0.7 then "advance" else "quake"
end
-- Straight after a sweep, the slam is the punish for greed.
if signals.last == "sweep" then
return if roll < 0.65 then "slam" else "sweep"
end
if signals.phase >= 3 and roll < 0.35 then
return "slam"
end
if signals.phase >= 2 and roll < 0.3 then
return "quake"
end
return if roll < 0.7 then "sweep" else "slam"
end
--------------------------------------------------------------------------------
Runtime.create({
id = "wethermon",
name = "Wethermon the Tombguard",
title = "Unique Scenario",
mobId = "wethermon",
maxHealth = 4800,
phases = 3,
rewardXp = 1900,
respawn = 60,
arena = ARENA,
--- The tomb's hall floor. Must match Tomb.server's FLOOR.
floorY = -26,
aggroRange = 46,
leash = 150,
punish = 1.6,
staggerTime = 2.4,
hitHeight = 6,
hurtboxBonus = 5,
--- Barely moves when hit. Four hundred years of not being moved.
knockbackScale = 0.35,
idleState = "idle",
animate = Anim.wethermon,
actions = Actions,
choose = choose,
onPhase = function(ctx, phase)
ctx.audio("screech")
Vfx.ring(ctx.position() + V(0, 0.3, 0), 34, TEAL, 0.9, 0.45)
Vfx.parryBurst(ctx.position() + V(0, 7, 0))
if phase >= 3 then
-- The seals break. He stops holding back.
for index = 1, 8 do
local angle = (index / 8) * math.pi * 2
local at = ctx.position() + V(math.cos(angle) * 22, 0, math.sin(angle) * 22)
Vfx.ring(V(at.X, ctx.groundAt(at.X, at.Z) + 0.2, at.Z), 9, TEAL, 1.2, 0.3)
end
end
end,
})
print(`[Wethermon] sealed at {ARENA}`)
]]>
-
Bunny
-
Actions
commit -> follow-through. The
anticipation is long and still (you read it), the commit is fast (you can't
react to it, only to the anticipation), and the follow-through leaves it
open (you get paid for reading it).
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Config = require(ReplicatedStorage.Shared.Config.Bunny)
local Motor = require(script.Parent.Motor)
local Actions = {}
local ATTACKS = Config.Attacks
local HOP = Config.Hop
--------------------------------------------------------------------------------
-- Shared beats
--------------------------------------------------------------------------------
--[[
The crouch. Tracks you until `commitAt`, then locks and the telegraph goes
solid. Returns the locked direction.
Locking partway is the core reading skill: walking away early doesn't save
you, and once it's committed you know exactly where it's going.
]]
local function windUp(ctx, attack, scale: number)
local locked = nil
local length = attack.dash and attack.distance or 0
ctx.audio("growl")
ctx.await(attack.windup * scale, "crouch", function(phase)
if not locked then
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
if phase >= attack.commitAt then
locked = ctx.facing()
ctx.eyeFlash()
ctx.audio("hitLight")
end
end
ctx.telegraph(true, locked ~= nil, locked or ctx.facing(), length, attack.radius)
end)
-- Assisted players get a held beat at the top of the coil before it
-- commits. It reads as the creature hanging on the edge of the lunge,
-- which is exactly the "heightened concentration" the effect is selling.
local hold = ctx.beginAssist()
if hold and hold > 0 then
ctx.await(hold, "crouch", function()
ctx.telegraph(true, true, locked or ctx.facing(), length, attack.radius)
end)
end
ctx.telegraph(false)
return locked or ctx.facing()
end
--- Travels a straight line at speed, hitting once. Used by both dash attacks.
--- The travel is measured against you rather than fixed, so the skid always
--- ends inside your reach — see `Motor.dashTravel`.
local function dashThrough(ctx, attack, direction: Vector3, scale: number)
local from = ctx.position()
local _, playerPosition = ctx.player()
local to =
Motor.dashTarget(from, direction, Motor.dashTravel(from, direction, playerPosition, attack), ctx.groundAt)
local landed = false
ctx.audio("dash")
ctx.audioAt("windRush", from)
ctx.vfx().speedLines(from + Vector3.new(0, 2, 0), to + Vector3.new(0, 2, 0), Color3.fromRGB(226, 34, 44))
ctx.trail(true)
ctx.await(attack.dash * scale, "dash", function(phase)
ctx.setPosition(from:Lerp(to, phase))
if not landed and ctx.strike(attack.radius, attack.damage) then
landed = true
end
end)
ctx.trail(false)
ctx.vfx().slash(ctx.position() + Vector3.new(0, 2, 0), direction, 9, Color3.fromRGB(255, 92, 96))
ctx.vfx().dust(ctx.position(), 0.9)
ctx.audioAt("slash", ctx.position())
return landed
end
--- Skid, wobble, resettle. The window you were reading the tell for.
local function recover(ctx, duration: number)
ctx.await(math.min(duration * 0.35, 0.3), "slashFollow")
ctx.await(duration * 0.65, "recover")
end
--------------------------------------------------------------------------------
-- Attacks
--------------------------------------------------------------------------------
function Actions.dashSlash(ctx, scale: number)
local attack = ATTACKS.dashSlash
local direction = windUp(ctx, attack, scale)
dashThrough(ctx, attack, direction, scale)
recover(ctx, attack.recover * scale)
end
function Actions.tripleDash(ctx, scale: number)
local attack = ATTACKS.tripleDash
for index = 1, attack.repeats do
-- Every repeat re-aims and re-telegraphs, so each is its own read
-- rather than one attack that happens to hit three times.
local direction = windUp(ctx, attack, scale * (if index == 1 then 1 else 0.85))
dashThrough(ctx, attack, direction, scale)
if index < attack.repeats then
ctx.await(attack.between * scale, "recover")
end
end
recover(ctx, attack.recover * scale)
end
--[[
The feint. Identical to a Dash Slash right up to just past the point a
Dash Slash would commit — so a player who has learned to parry the instant
the telegraph goes solid gets punished for it, and has to learn to parry on
the dash instead.
]]
function Actions.fakeAttack(ctx, scale: number)
local attack = ATTACKS.fakeAttack
ctx.audio("growl")
ctx.await(attack.windup * attack.cancelAt * scale, "crouch", function(phase)
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
-- Sells it: the telegraph goes solid, exactly as it would for a real one,
-- at the same width and the same reach.
ctx.telegraph(true, phase >= 0.88, ctx.facing(), ATTACKS.dashSlash.distance, ATTACKS.dashSlash.radius)
end)
ctx.telegraph(false)
ctx.audioAt("hop", ctx.position())
ctx.vfx().dust(ctx.position(), 0.7)
-- Twists out of the crouch and relocates behind you in one motion.
local _, playerPosition, playerLook = ctx.player()
local behind = if playerPosition
then Motor.behindTarget(playerPosition, playerLook, attack.behindDistance, ctx.groundAt)
else ctx.position()
local from = ctx.position()
ctx.trail(true)
ctx.await(attack.reposition * scale, "feint", function(phase)
ctx.setPosition(Motor.arc(from, behind, HOP.longHeight, phase))
end)
ctx.trail(false)
ctx.vfx().landing(behind, 0.8)
ctx.audioAt("land", behind)
local _, nowPosition = ctx.player()
if nowPosition then
ctx.face(nowPosition - ctx.position())
end
ctx.await(attack.recover * scale, "recover")
end
--[[
Leap. Rises out of view, hangs, then inverts and comes down on top of you.
The hang is the whole point: you lose sight of it and have to move.
It used to re-aim at your feet for the entire hang, which meant the landing
spot was only fixed 0.2s before impact across an 11-stud radius. Nothing on
foot covers 11 studs in 0.2s, so the one attack in the move set documented
as having to be *moved out of* was the one attack that could not be, and at
104 damage against 100 starting health it killed outright rather than
leaving the sliver everything else in this fight leaves.
Now it stops re-aiming partway through the hang and the committed spot is
drawn on the ground. What you lose sight of is the creature; what you are
given instead is a circle and just under four tenths of a second, which is a
sprint and not a walk. The guess is still real — it is guessing whether to
break early and eat the stamina, or hold and trust your read.
]]
function Actions.leapAttack(ctx, scale: number)
local attack = ATTACKS.leapAttack
local from = ctx.position()
ctx.audio("growl")
-- No ground indicator during the coil. Drawing the dash's forward lane here
-- made the two windups look identical at exactly the moment their answers
-- diverge — one is parried standing still, the other has to be run from.
-- The commit still gets the eye flash every other attack gets, so the tell
-- reads as "it has decided" rather than "it is going that way".
local committed = false
ctx.await(attack.windup * scale, "crouch", function(phase)
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
if not committed and phase >= attack.commitAt then
committed = true
ctx.eyeFlash()
ctx.audio("hitLight")
end
end)
local apex = from + Vector3.new(0, attack.height, 0)
ctx.audioAt("windRush", from)
ctx.vfx().dust(from, 1.2)
ctx.await(attack.rise * scale, "leapRise", function(phase)
ctx.setPosition(from:Lerp(apex, phase ^ 0.7))
end)
-- Re-aims for the first `trackUntil` of the hang, then locks and marks it.
-- Falls back to where it took off from, not to the apex: with nobody to
-- track, the old default left it hanging 46 studs in the air.
local landing = Vector3.new(from.X, ctx.groundAt(from.X, from.Z), from.Z)
ctx.await(attack.hang * scale, "leapHang", function(phase)
if phase < attack.trackUntil then
local _, playerPosition = ctx.player()
if playerPosition then
landing =
Vector3.new(playerPosition.X, ctx.groundAt(playerPosition.X, playerPosition.Z), playerPosition.Z)
ctx.face(playerPosition - ctx.position())
end
else
ctx.marker(true, landing, attack.radius, true)
end
end)
local dropFrom = ctx.position()
local target = landing
ctx.trail(true)
ctx.await(attack.fall * scale, "leapFall", function(phase)
ctx.setPosition(dropFrom:Lerp(target, phase ^ 1.8))
ctx.marker(true, target, attack.radius, true)
end)
ctx.trail(false)
ctx.marker(false)
-- Impact.
ctx.setPosition(target)
-- Unparryable: this one has to be moved out of, not answered.
ctx.strike(attack.radius, attack.damage, attack.unparryable)
ctx.vfx().landing(target, 2.2)
ctx.vfx().ring(target + Vector3.new(0, 0.2, 0), attack.radius * 1.6, Color3.fromRGB(255, 120, 90), 0.45, 0.35)
ctx.vfx().leaves(target, 14)
ctx.audioAt("heavyLand", target)
ctx.shakeArena(target, 1.4)
recover(ctx, attack.recover * scale)
end
--[[
Close-range spin. Multiple hits, each one its own parry check.
Marked with a disc rather than the forward lane it used to draw. This attack
hits everything within 8.5 studs of the creature in every direction — 17
studs across, against a lane that was drawn 12 wide and pointing one way, so
standing behind it or off to the side put you outside everything the game
had told you was dangerous and still inside the damage. The disc also has to
follow, because the spin drifts toward you while it turns.
]]
function Actions.spinSlash(ctx, scale: number)
local attack = ATTACKS.spinSlash
ctx.audio("screech")
ctx.await(attack.windup * scale, "crouch", function(phase)
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
ctx.marker(true, ctx.position(), attack.radius, phase >= attack.commitAt)
end)
ctx.trail(true)
for _ = 1, attack.hits do
ctx.audioAt("spin", ctx.position())
ctx.await(attack.between * scale, "spin", function()
-- Drifts toward you through the spin so it can't be simply walked
-- out of, but slowly enough that it can be.
local _, playerPosition = ctx.player()
if playerPosition then
local toward = Motor.flatten(playerPosition - ctx.position())
ctx.setPosition(ctx.position() + toward * 0.14)
end
ctx.marker(true, ctx.position(), attack.radius, true)
end)
ctx.strike(attack.radius, attack.damage)
ctx.vfx().slash(ctx.position() + Vector3.new(0, 1.8, 0), ctx.facing(), 7, Color3.fromRGB(255, 140, 120))
end
ctx.trail(false)
ctx.marker(false)
recover(ctx, attack.recover * scale)
end
--- Disengage. Buys it space, buys you nothing.
function Actions.retreat(ctx, scale: number)
local attack = ATTACKS.retreat
for _ = 1, attack.hops do
local _, playerPosition = ctx.player()
local away = if playerPosition then -Motor.flatten(playerPosition - ctx.position()) else ctx.facing()
-- Backward *and* sideways, so a retreat still isn't a straight line.
local skew = Vector3.new(-away.Z, 0, away.X) * ((math.random() - 0.5) * 1.4)
local landing = ctx.position() + (away + skew).Unit * HOP.longDistance
ctx.hop(
Vector3.new(landing.X, ctx.groundAt(landing.X, landing.Z), landing.Z),
HOP.longHeight * 0.7,
HOP.longAirTime * scale
)
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
end
ctx.await(attack.recover * scale, "observe")
end
--[[
Parried. Reeling and wide open — this is the window the whole guard
mechanic exists to buy, so it is long enough to land a full combo chain and
poses distinctly enough that you can tell it apart from an ordinary
recovery at a glance.
]]
function Actions.stagger(ctx, duration: number)
ctx.audio("screech")
ctx.await(duration, "stagger")
-- Shakes it off and immediately re-orients on you.
local _, playerPosition = ctx.player()
if playerPosition then
ctx.face(playerPosition - ctx.position())
end
ctx.await(0.25, "observe")
end
--------------------------------------------------------------------------------
-- Between attacks
--------------------------------------------------------------------------------
--[[
The rest behaviour, and the most important one for how the fight *reads*.
It is never standing still. It circles, occasionally reverses, sometimes
vaults onto a rock, and sometimes ducks behind a tree before an attack. The
brief `observe` beats between hops are where the head tracking and ear
twitches live — it is watching you the whole time.
]]
function Actions.circle(ctx, hops: number, scale: number)
for index = 1, hops do
local _, playerPosition = ctx.player()
if not playerPosition then
return
end
if math.random() < HOP.reverseChance then
ctx.reverseSpin()
end
local useCover = index == hops and math.random() < 0.3
local landing = nil
if useCover then
landing = ctx.coverTarget(playerPosition)
end
if not landing then
landing = Motor.circleTarget(
ctx.position(),
playerPosition,
Config.Perception.circleRadius,
ctx.spin(),
HOP.lateralBias,
HOP.mediumDistance,
ctx.groundAt
)
end
local vault = math.random() < HOP.vaultChance
ctx.hop(
landing,
(if vault then HOP.longHeight else HOP.height) * scale,
(if vault then HOP.longAirTime else HOP.airTime) * scale
)
ctx.face(playerPosition - ctx.position())
-- A held beat, watching. Short, so it never reads as idling.
ctx.await(0.1 + math.random() * 0.16, "observe")
end
end
return Actions
]]>
-
Brain
spin, or disengage. far -> leap or triple dash
playerStamina low -> press hard; you can't block or dodge much
recentParries high -> feint. You have learned to bite, so bait it
aggression high -> make space and force you to come to it
healthFraction low -> frenzy; faster, and far more feints
The parry-punish rule is the one that makes it feel like it is reading you.
A player who learns the parry starts winning cleanly, so the creature starts
throwing fake attacks that look identical up to the commit point. The
counter-play is to stop parrying on sight and start parrying on *commit* —
which is a harder skill, learned because the boss taught it.
Returns (actionName, debugScores) so tuning can be inspected live.
]]
local Config = require(game:GetService("ReplicatedStorage").Shared.Config.Bunny)
local Brain = {}
local CANDIDATES = { "dashSlash", "tripleDash", "fakeAttack", "leapAttack", "spinSlash", "retreat" }
local function apply(scores, table_)
if not table_ then
return
end
for name, multiplier in table_ do
if scores[name] then
scores[name] *= multiplier
end
end
end
--[[
`signals` fields:
distance studs to the player
stamina 0-1 fraction of the player's stamina
parries parries landed on it inside the memory window
aggression player attacks inside the aggression window
health 0-1 fraction of its own health
last previously chosen action name
]]
function Brain.choose(signals)
local utility = Config.Utility
local scores = {}
for _, name in CANDIDATES do
local attack = Config.Attacks[name]
scores[name] = attack and attack.weight or 0.5
end
-- Spacing dictates what is even sensible.
if signals.distance <= Config.Perception.crowdedRange then
apply(scores, utility.closeUp)
elseif signals.distance >= Config.Perception.farRange then
apply(scores, utility.farOff)
end
-- You are out of stamina. This is the moment to be unfair.
if signals.stamina <= utility.staminaBelow then
apply(scores, utility.pressAdvantage)
end
-- You have been parrying it. Start selling fakes.
if signals.parries >= utility.parryMemory then
apply(scores, utility.parryPunish)
end
-- You have been swinging a lot. Take the space away.
if signals.aggression >= utility.aggressionThreshold then
apply(scores, utility.spacing)
end
-- Frenzy leans on feints and pressure rather than raw repetition.
local frenzied = signals.health <= Config.Frenzy.below
if frenzied then
scores.fakeAttack = (scores.fakeAttack or 0) * (1 + Config.Frenzy.fakeBonus)
scores.retreat = (scores.retreat or 0) * 0.5
end
-- Never twice running unless everything else scored terribly.
if signals.last and scores[signals.last] then
scores[signals.last] *= utility.repeatPenalty
end
-- Retreat is a spacing tool, never an opener.
if signals.distance > Config.Perception.circleRadius then
scores.retreat = (scores.retreat or 0) * 0.25
end
local best, bestScore = "dashSlash", -1
for name, score in scores do
local jittered = score * (1 + (math.random() - 0.5) * 2 * utility.noise)
if jittered > bestScore then
best, bestScore = name, jittered
end
end
return best, scores
end
--- Rest between actions, shortened in frenzy. It is circling throughout, so
--- this is thinking time, not standing time.
function Brain.restDuration(health: number): number
local rest = Config.Rest
local base = rest.min + math.random() * (rest.max - rest.min)
if health <= Config.Frenzy.below then
base *= Config.Frenzy.timing
end
return base
end
return Brain
]]>
-
Motor
number
): Vector3
local toPlayer = playerPosition - position
local flat = flatten(toPlayer)
local gap = Vector3.new(toPlayer.X, 0, toPlayer.Z).Magnitude
-- Radial component: close if too far, back off if too near, hold if inside
-- a comfortable band. The band stops it oscillating in and out.
local radial = 0
if gap > radius + 4 then
radial = 1
elseif gap < radius - 5 then
radial = -1
end
local tangent = Vector3.new(-flat.Z, 0, flat.X) * spin
local direction = (flat * radial * (1 - lateralBias) + tangent * lateralBias)
if direction.Magnitude < 0.01 then
direction = tangent
end
local landing = position + direction.Unit * distance
return Vector3.new(landing.X, groundAt(landing.X, landing.Z), landing.Z)
end
--- Directly behind the player, relative to where they're looking. Used by the
--- feint, which is the whole reason the fake attack is frightening.
function Motor.behindTarget(
playerPosition: Vector3,
playerLook: Vector3,
distance: number,
groundAt: (number, number) -> number
): Vector3
local back = -flatten(playerLook)
-- Offset slightly off the exact centreline so it doesn't land in a
-- perfectly readable spot every time.
local skew = Vector3.new(-back.Z, 0, back.X) * ((math.random() - 0.5) * 6)
local landing = playerPosition + back * distance + skew
return Vector3.new(landing.X, groundAt(landing.X, landing.Z), landing.Z)
end
--- A landing spot that puts something solid between it and you. Breaking line
--- of sight before an attack is the difference between an enemy that moves and
--- one that hunts.
function Motor.coverTarget(
position: Vector3,
playerPosition: Vector3,
obstacles: { Vector3 },
maxRange: number,
groundAt: (number, number) -> number
): Vector3?
local best, bestScore = nil, 0
for _, obstacle in obstacles do
local toObstacle = obstacle - position
if Vector3.new(toObstacle.X, 0, toObstacle.Z).Magnitude > maxRange then
continue
end
-- Prefer cover that is roughly between us and the player, and not so
-- close to them that hiding is pointless.
local fromPlayer = obstacle - playerPosition
local gap = Vector3.new(fromPlayer.X, 0, fromPlayer.Z).Magnitude
if gap < 9 then
continue
end
local behind = obstacle + flatten(fromPlayer) * 4
local score = 1 / (1 + math.abs(gap - 20)) + math.random() * 0.4
if score > bestScore then
best, bestScore = behind, score
end
end
if not best then
return nil
end
return Vector3.new(best.X, groundAt(best.X, best.Z), best.Z)
end
--- Straight-line dash destination, clamped to the arena floor.
function Motor.dashTarget(
position: Vector3,
direction: Vector3,
distance: number,
groundAt: (number, number) -> number
): Vector3
local landing = position + flatten(direction) * distance
return Vector3.new(landing.X, groundAt(landing.X, landing.Z), landing.Z)
end
--[[
How far a dash should actually travel.
The naive answer is a flat `attack.distance`, which is what this used to do,
and it turns the punish window into a lottery. Thrown from on top of you a
33-stud dash ends 24 studs past; thrown from its circling radius it ends 14
past; only from somewhere in the middle does it stop inside your 11-stud
reach. The long recovery exists so you can hit it, and you can only hit it
if you can reach it — the fight had this exact failure once before, at 27
studs of overshoot, and it was unwinnable.
So it aims to stop `overshoot` studs beyond you, measured *along the locked
direction* rather than as a straight-line distance. The direction commits
partway through the windup and you have the rest of it to step off that
line, so sidestepping the commit makes the dash sail harmlessly past. That
is the payoff for reading it, and it only works if the travel is measured
against the line rather than against you.
`minDistance` keeps a dash thrown from point-blank reading as a dash rather
than a twitch; `distance` remains the ceiling, so out of range it falls
short and whiffs.
]]
function Motor.dashTravel(position: Vector3, direction: Vector3, playerPosition: Vector3?, attack): number
if not playerPosition then
return attack.distance
end
local toPlayer = playerPosition - position
local along = flatten(direction):Dot(Vector3.new(toPlayer.X, 0, toPlayer.Z))
return math.clamp(along + attack.overshoot, attack.minDistance, attack.distance)
end
Motor.flatten = flatten
return Motor
]]>
-
Colosseum
0
0.1 then
entry.facing = entry.facing:Lerp(flat.Unit, math.clamp(dt * 6, 0, 1))
end
if entry.state == "close" then
if distance > REACH then
-- Fighters keep a little distance from each other so a wave arrives
-- as a ring rather than a single overlapping blob.
local separation = V(0, 0, 0)
for _, other in fighters do
if other ~= entry then
local away = entry.position - other.position
if away.Magnitude < 9 and away.Magnitude > 0.1 then
separation += away.Unit * (9 - away.Magnitude) * 0.4
end
end
end
entry.position += (flat.Unit * entry.speed + separation) * dt
else
entry.state = "telegraph"
entry.timer = WINDUP
Vfx.closingRing(entry.position + V(0, 0.3, 0), REACH, Color3.fromRGB(255, 170, 90), WINDUP)
Audio.playAt("growl", entry.position)
end
elseif entry.state == "telegraph" and entry.timer <= 0 then
entry.state = "recover"
entry.timer = RECOVER
Audio.playAt("slash", entry.position)
Vfx.slash(entry.position + V(0, 4, 0), entry.facing, 6, Color3.fromRGB(255, 220, 180))
if distance <= REACH + 1.5 then
-- Straight through Guard, so blocking and parrying work here
-- exactly as they do against the bosses.
Guard.resolve(player, { damage = entry.damage, from = entry.position })
end
elseif entry.state == "recover" and entry.timer <= 0 then
entry.state = "close"
end
local moving = entry.state == "close" and distance > REACH
entry.phase += dt * (if moving then 9 else 2)
local bob = if moving then math.abs(math.sin(entry.phase)) * 0.5 else math.sin(entry.phase) * 0.12
local lunge = if entry.state == "telegraph" then -0.7 else 0
Net.publish(
entry.model,
CFrame.lookAt(entry.position + V(0, bob, 0), entry.position + entry.facing + V(0, bob, 0))
* CFrame.new(0, 0, lunge),
entry.state,
entry.phase,
nil
)
end
--------------------------------------------------------------------------------
-- The run
--------------------------------------------------------------------------------
local function clearFighters()
for _, entry in fighters do
if entry.model then
entry.model:Destroy()
end
end
table.clear(fighters)
end
local function announce(text: string, sub: string?)
local player = run.player
if player then
Network.ArenaState:FireClient(player, {
active = run.active,
wave = run.wave,
totalWaves = #WAVES,
remaining = #fighters,
banner = text,
sub = sub,
})
end
end
local function endRun(won: boolean)
local player = run.player
clearFighters()
run.active = false
run.wave = 0
if not player then
return
end
if won then
Profile.addGold(player, run.gold + RUN_BONUS)
Profile.recordKill(player, "colosseum_run")
Network.EnemyDefeated:FireClient(player, "colosseum", RUN_XP)
Audio.playAt("levelUp", ARENA.center)
Vfx.parryBurst(ARENA.center + V(0, 6, 0))
announce("RUN CLEARED", `{run.gold + RUN_BONUS} gold`)
else
announce("RUN ENDED", "The floor is yours again when you are.")
end
Audio.stopMusic()
run.player = nil
run.gold = 0
task.delay(4, function()
if not run.active then
Network.ArenaState:FireClient(player, nil)
end
end)
end
local function startRun(player: Player)
if run.active then
return false
end
run.active = true
run.player = player
run.wave = 0
run.gold = 0
Audio.startMusic()
task.spawn(function()
for index, wave in WAVES do
if not run.active then
return
end
run.wave = index
Audio.setIntensity(index + 1)
announce(`WAVE {index} / {#WAVES}`, `{wave.count} incoming`)
for slot = 1, wave.count do
spawnFighter(slot, wave)
end
-- Wait for the floor to clear, or for the run to be abandoned.
while run.active and #fighters > 0 do
task.wait(0.25)
end
if not run.active then
return
end
run.gold += wave.gold
Profile.addGold(player, wave.gold)
if index < #WAVES then
announce(`WAVE {index} CLEAR`, `{BREATHER}s — next wave incoming`)
task.wait(BREATHER)
end
end
if run.active then
endRun(true)
end
end)
return true
end
--------------------------------------------------------------------------------
-- Damage in
--------------------------------------------------------------------------------
--[[
Player swings land on the nearest fighter in reach.
Shares the Attack remote with the rest of the game, and picks a single
target rather than cleaving: in a crowd, "which one did I just hit" has to
be answerable, and a swing that quietly damages four enemies makes crowd
positioning meaningless.
]]
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" or not run.active or run.player ~= player then
return
end
local root = rootOf(player)
if not root then
return
end
local step = Encounters.comboStep(comboIndex)
local best, bestIndex, bestDistance = nil, nil, Encounters.PlayerAttack.range
for index, entry in fighters do
local distance = (entry.position - root.Position).Magnitude
if distance < bestDistance then
best, bestIndex, bestDistance = entry, index, distance
end
end
if not best then
return
end
best.health -= step.damage
local at = best.position + V(0, 4, 0)
Vfx.sparks(at, if step.knockback >= 30 then 18 else 9, Color3.fromRGB(255, 226, 170))
Vfx.slash(at, root.CFrame.LookVector, 6, Color3.fromRGB(255, 240, 210))
Audio.playAt(if step.knockback >= 30 then "hitHeavy" else "hitLight", at)
Network.BossDamaged:FireClient(player, step.damage, "normal", at)
Network.Impact:FireClient(player, if step.knockback >= 30 then "heavy" else "light")
-- Knocked back, so a heavy swing visibly buys space in a crowd.
if step.knockback > 0 and bestDistance > 0.1 then
local away = (best.position - root.Position).Unit
best.position += away * (step.knockback * 0.06)
end
if best.health <= 0 then
killFighter(best, bestIndex)
announce(`WAVE {run.wave} / {#WAVES}`, `{#fighters} left`)
end
end)
--------------------------------------------------------------------------------
Network.Arena.OnServerEvent:Connect(function(player, action)
if action == "start" then
local root = rootOf(player)
if not root then
return
end
-- Must actually be standing at the arena. The gate NPC is the intended
-- route in, but the check is on position, not on having talked to him.
if (V(root.Position.X, 0, root.Position.Z) - ARENA.center).Magnitude > ARENA.radius + 80 then
return
end
startRun(player)
elseif action == "leave" and run.player == player then
endRun(false)
end
end)
Players.PlayerRemoving:Connect(function(player)
if run.player == player then
endRun(false)
end
end)
--------------------------------------------------------------------------------
local function build()
local existing = Workspace:FindFirstChild(FOLDER)
if existing then
existing:Destroy()
end
folder = Create("Folder", { Name = FOLDER, Parent = Workspace })
buildArena()
print(`[Colosseum] arena ready at {ARENA.center} — {#WAVES} waves`)
end
build()
RunService.Heartbeat:Connect(function(dt)
local player = run.player
if not (run.active and player) then
return
end
-- Dying, or wandering off the floor, ends the run rather than leaving
-- fighters swinging at nobody.
local root = rootOf(player)
if not root then
endRun(false)
return
end
if (V(root.Position.X, 0, root.Position.Z) - ARENA.center).Magnitude > ARENA.radius + 60 then
endRun(false)
return
end
for index = #fighters, 1, -1 do
local entry = fighters[index]
if entry.health <= 0 then
killFighter(entry, index)
else
stepFighter(entry, dt, player)
end
end
end)
]]>
-
Combat
-
Assist
= Config.SuccessesBeforeOff then
state.failures = 0
else
state.failures = math.max(state.failures - Config.FailuresPerSuccess, 0)
end
end
--- An assisted attack landed without being parried, or a press whiffed.
--- Help arrives slowly: you have to genuinely struggle before it offers.
function Assist.recordFailure(player: Player)
local state = stateFor(player)
state.successStreak = 0
state.failures = math.min(state.failures + 1, Config.MaxFailures)
end
function Assist.reset(player: Player)
local state = stateFor(player)
state.failures = 0
state.successStreak = 0
state.pending = false
end
--------------------------------------------------------------------------------
--- How far the slow has ramped, 0-1, from accumulated failures.
local function strengthFrom(failures: number): number
return math.clamp(failures / Config.FailuresForFullStrength, 0, 1)
end
--[[
What the player should get right now: the slow amount, and which stage of
visible help. Returns nil for no assist at all.
Off never assists.
Always sits permanently at the ring stage — slowed and ringed, but never
prompted. The key prompt is something a struggling player earns;
handing it out by setting would undercut the whole escalation.
Adaptive escalates by failures and collapses on success.
]]
local function currentAssist(state: State)
if state.mode == "off" then
return nil
end
if state.mode == "always" then
local stage = Config.Stages[Config.AlwaysTier]
local strength = math.max(strengthFrom(state.failures), Config.AlwaysStrength)
return strength, stage
end
local stage = Config.stageFor(state.failures)
if not stage then
return nil
end
return strengthFrom(state.failures), stage
end
--[[
Called immediately before an attack commits to its impact.
Returns a profile when the approach should be stretched, or nil to strike at
full speed. On a profile, the caller must:
1. wait `profile.lead / profile.slow` real seconds
2. then resolve the hit
The client is told the same numbers so its ring closes exactly on impact.
]]
--- Works out the profile without announcing it. Callers that need the timing
--- up front — to size a telegraph that has to close on impact — plan first and
--- announce at the moment the ring should actually start.
--- Current stage, for anything that wants to report progress.
function Assist.stageOf(player: Player)
local _, stage = currentAssist(stateFor(player))
return stage
end
function Assist.plan(player: Player)
local state = stateFor(player)
local strength, stage = currentAssist(state)
if not (strength and stage) then
return nil
end
local profile = Config.profile(strength, stage)
--- Real seconds of ring the player actually sees.
profile.realLead = profile.lead / profile.slow
--[[
LATENCY COMPENSATION — without this the whole system is unwinnable.
The prompt takes half a round trip to reach the client, and the press
takes half a round trip to come back. So a player who presses at the
exact moment their ring closes has their press arrive a full round trip
after the server started counting. If the server resolves the hit at
`realLead`, that press lands *after* the attack already resolved. Every
time. No amount of timing skill beats it.
So the server holds the strike for the ring plus the measured round
trip, and biases a little later still: pressing early is forgiving
(your window stays open), pressing late is not.
]]
local ping = 0
pcall(function()
ping = player:GetNetworkPing()
end)
ping = math.clamp(ping, 0, Config.MaxCompensation)
profile.ping = ping
profile.impactDelay = profile.realLead + ping + Config.ImpactBias
return profile
end
--- Fires the prompt and opens the grading window. Call this exactly
--- `profile.impactDelay` before the hit resolves.
function Assist.announce(player: Player, profile)
local state = stateFor(player)
state.pending = true
state.token += 1
local token = state.token
Network.ParryPrompt:FireClient(player, profile)
-- Safety net. An attack that never resolves — you dodged clean out of
-- range, the enemy was interrupted, the drill stopped — would otherwise
-- leave `pending` stuck and the streak ungraded forever.
task.delay(profile.impactDelay + 1.5, function()
local current = states[player]
if current and current.pending and current.token == token then
current.pending = false
Network.ParryPrompt:FireClient(player, nil)
end
end)
return profile
end
--- Plan and announce together, for callers that strike immediately after.
function Assist.begin(player: Player)
local profile = Assist.plan(player)
if profile then
Assist.announce(player, profile)
end
return profile
end
--- Grades the attack that `announce` opened, then clears the prompt.
function Assist.finish(player: Player, parried: boolean)
local state = stateFor(player)
local wasPending = state.pending
state.pending = false
state.token += 1
if parried then
Assist.recordSuccess(player)
else
Assist.recordFailure(player)
end
if wasPending then
Network.ParryPrompt:FireClient(player, nil)
end
end
--- Grading for attacks that were never assisted, so streaks still track.
function Assist.grade(player: Player, parried: boolean)
if parried then
Assist.recordSuccess(player)
else
Assist.recordFailure(player)
end
end
Players.PlayerRemoving:Connect(function(player)
states[player] = nil
end)
return Assist
]]>
-
Guard
0 then
Network.GuardResult:FireClient(player, -tier.refund, true)
else
Network.GuardResult:FireClient(player, 0, true)
end
Vfx.parryBurst(at)
Audio.playAt("parry", from)
Network.Impact:FireClient(player, "parry", { position = at })
return "parried", Parry.forRank(state.rank).stagger
end
-- 3. Blocked — or broken.
if state.blockedAt then
-- The guard break. Without this, block is a flat 78% wall that keeps
-- working forever once stamina hits zero, because the cost is only ever
-- subtracted client-side and nothing checks the result. "Blocking is a
-- resource, not a wall" was true of the config comment and false of the
-- game. Turning up with an empty bar now costs you the whole hit.
if state.stamina < BLOCK.guardBreakBelow then
-- Guard drops. Re-raising it is a deliberate press, so a broken
-- guard cannot silently keep absorbing the rest of a combo.
state.blockedAt = nil
local direction = if root then (root.Position - from) else Vector3.new(0, 0, -1)
direction = Vector3.new(direction.X, 0, direction.Z)
direction = if direction.Magnitude < 0.01 then Vector3.new(0, 0, -1) else direction.Unit
Network.PlayerDamaged:FireClient(player, damage)
Network.Impact:FireClient(player, "guardBreak", { direction = direction, power = Parry.FailShove * 1.3 })
Audio.playAt("guardBreak", from)
Vfx.sparks(at, 26, Color3.fromRGB(255, 120, 90))
return "broken", 0
end
local through = math.floor(damage * (1 - BLOCK.damageReduction))
Network.PlayerDamaged:FireClient(player, through)
Network.GuardResult:FireClient(player, BLOCK.staminaPerHit, false)
Network.Impact:FireClient(player, "blocked")
Audio.playAt("blocked", from)
Vfx.sparks(at, 18, Color3.fromRGB(200, 220, 255))
return "blocked", 0
end
-- 4. Straight through.
local direction = if root then (root.Position - from) else Vector3.new(0, 0, -1)
direction = Vector3.new(direction.X, 0, direction.Z)
direction = if direction.Magnitude < 0.01 then Vector3.new(0, 0, -1) else direction.Unit
Network.PlayerDamaged:FireClient(player, damage)
Network.Impact:FireClient(player, "hurt", { direction = direction, power = Parry.FailShove })
Vfx.bloodSlash(at, direction)
Audio.playAt("hurt", from)
return "hit", 0
end
--- Self-driven, once a frame. This used to be called from the Vorpal Bunny's
--- heartbeat, which meant parry windows stopped closing during its respawn —
--- a stale window could then answer an attack it was never opened for, and the
--- whiff lockout silently stopped applying. Guard is used by every enemy and
--- by the training yard, so it owns its own clock.
local function tick()
local now = os.clock()
for player, state in states do
if state.parryUntil and now > state.parryUntil then
state.parryUntil = nil
-- Whiffed. Lock out attacking for the rank's recovery.
local tier = Parry.forRank(state.rank)
state.recoveryUntil = now + (tier and tier.recovery or 0.4)
Network.Impact:FireClient(player, "parryWhiff")
-- A press into empty air counts against you: the assist should
-- notice someone mashing F as much as someone never pressing it.
Assist.recordFailure(player)
end
end
end
--------------------------------------------------------------------------------
-- Remotes
--------------------------------------------------------------------------------
--[[
These live here, not in an enemy script.
They were originally connected inside the Vorpal Bunny's script, which meant
the entire guard system — parry, block, dodge, rank — was silently coupled
to one creature existing. The training yard uses Guard too, and so will
every enemy added later. Global player state belongs with the global module.
]]
--- The rank rides along with the press. The periodic vitals report can be up to
--- 250ms stale, and a player who just unlocked the parry pressing F inside that
--- window would be told they don't have it.
Network.Parry.OnServerEvent:Connect(function(player, claimedRank)
if typeof(claimedRank) == "number" then
Guard.setRank(player, claimedRank)
end
local accepted, reason, cooldown, window = Guard.requestParry(player)
Network.ParryResult:FireClient(player, accepted, reason, cooldown, window)
end)
Network.Block.OnServerEvent:Connect(function(player, holding)
Guard.setBlocking(player, holding == true)
end)
--- The periodic vitals report. This used to be connected inside the Vorpal
--- Bunny's script, which meant the guard break only existed while that one
--- creature was alive; every other enemy saw a permanently full stamina bar and
--- could never break a guard. Same reasoning as the remotes above.
Network.Vitals.OnServerEvent:Connect(function(player, stamina, parryRank)
Guard.setStamina(player, stamina)
Guard.setRank(player, parryRank or 0)
end)
Network.Invulnerable.OnServerEvent:Connect(function(player, duration)
Guard.setInvulnerable(player, duration)
end)
RunService.Heartbeat:Connect(tick)
Players.PlayerRemoving:Connect(function(player)
states[player] = nil
end)
return Guard
]]>
-
DayNight
0
0.05 then
lastBroadcastHour = clockHour
Network.TimeOfDay:FireAllClients(clockHour, Sky.isNight(clockHour))
end
local night = Sky.isNight(clockHour)
if night ~= wasNight then
wasNight = night
print(`[DayNight] {if night then "nightfall" else "daybreak"} at {string.format("%.1f", clockHour)}`)
end
end)
print(`[DayNight] clock running — {Sky.SecondsPerHour}s per hour, full day {Sky.SecondsPerHour * 24 / 60}min`)
]]>
-
Encounter
0
0 and staggerScale or 1)
hitstopUntil = os.clock() + HITSTOP.parry
knockback = -facing * Parry.Shove
updateTelegraph(false)
updateMarker(false)
shakeArena(position, 1.2)
broadcastImpact("parry", { position = position })
end
return true
end
--------------------------------------------------------------------------------
-- Action context
--------------------------------------------------------------------------------
local ctx = {}
ctx.groundAt = groundAt
ctx.vfx = function()
return Vfx
end
function ctx.position()
return position
end
function ctx.setPosition(value: Vector3)
position = value
end
function ctx.facing()
return facing
end
function ctx.face(direction: Vector3)
facing = Motor.flatten(direction)
end
function ctx.spin()
return spin
end
function ctx.reverseSpin()
spin = -spin
end
function ctx.player()
return nearestPlayer()
end
function ctx.audio(name: string)
Audio.playAt(name, position)
end
function ctx.audioAt(name: string, at: Vector3)
Audio.playAt(name, at)
end
function ctx.shakeArena(origin: Vector3, power: number)
shakeArena(origin, power)
end
function ctx.telegraph(visible: boolean, committed: boolean?, direction: Vector3?, length: number?, radius: number?)
updateTelegraph(visible, committed, direction, length, radius)
end
function ctx.marker(visible: boolean, at: Vector3?, radius: number?, committed: boolean?)
updateMarker(visible, at, radius, committed)
end
function ctx.eyeFlash()
setEyeGlow(1)
task.delay(0.18, function()
setEyeGlow(0)
end)
end
function ctx.trail(enabled: boolean)
if trail then
trail.Enabled = enabled
end
end
--- Opens an assisted approach for whoever is being attacked, and returns how
--- long the creature should hold before committing (0 for no assist).
function ctx.beginAssist(): number
local player = nearestPlayer()
if not player then
return 0
end
local profile = Assist.begin(player)
return if profile then profile.impactDelay else 0
end
function ctx.coverTarget(playerPosition: Vector3)
return Motor.coverTarget(position, playerPosition, obstacles, HOP.longDistance * 1.6, groundAt)
end
--- Yields for `duration`, holding an animation state and ticking its phase.
function ctx.await(duration: number, stateName: string, onUpdate)
animState = stateName
local elapsed = 0
-- Zero-length beats still need one frame, or the pose never renders.
repeat
local dt = coroutine.yield()
if aborted then
error(ABORT)
end
elapsed += dt
animPhase = if duration > 0 then math.clamp(elapsed / duration, 0, 1) else 1
if onUpdate then
onUpdate(animPhase, dt)
end
until elapsed >= duration
end
--- One full hop: compress, launch, arc, land, squash.
function ctx.hop(target: Vector3, height: number, airTime: number)
local from = position
ctx.await(HOP.compress, "compress")
Audio.playAt("hop", from)
Vfx.dust(from, 0.45)
ctx.await(airTime, "air", function(phase)
position = Motor.arc(from, target, height, phase)
end)
position = target
Vfx.landing(target, 0.55)
Audio.playAt("land", target)
ctx.await(HOP.land, "land")
end
--- Hits the player if they're inside `radius`. Returns whether anything landed.
function ctx.strike(radius: number, damage: number, unparryable: boolean?): boolean
local player, playerPosition = nearestPlayer()
if not (player and playerPosition) then
return false
end
local flat = Vector3.new(playerPosition.X - position.X, 0, playerPosition.Z - position.Z)
if flat.Magnitude > radius then
return false
end
return resolveHit(player, damage, unparryable)
end
--------------------------------------------------------------------------------
-- Spawning
--------------------------------------------------------------------------------
local function cacheObstacles()
table.clear(obstacles)
local forest = Workspace:FindFirstChild("RampantForest")
if not forest then
return
end
local arena = World.BunnyArena
for _, model in forest:GetChildren() do
if not model:IsA("Model") or not model.PrimaryPart then
continue
end
local at = model.PrimaryPart.Position
if (Vector3.new(at.X, 0, at.Z) - Vector3.new(arena.X, 0, arena.Z)).Magnitude < World.BunnyArenaRadius + 45 then
table.insert(obstacles, at)
end
end
end
local function despawn()
if bunny then
bunny:Destroy()
end
if telegraph then
telegraph:Destroy()
end
if marker then
marker:Destroy()
end
bunny, rig, telegraph, marker, trail = nil, nil, nil, nil, nil
table.clear(eyes)
end
local function spawnBunny()
despawn()
local arena = World.BunnyArena
position = Vector3.new(arena.X, groundAt(arena.X, arena.Z), arena.Z)
facing = Vector3.new(0, 0, 1)
local model = Mobs.build("vorpal_bunny", CFrame.new(position))
if not model then
warn("[Encounter] could not build the Vorpal Bunny")
return
end
model.Name = "VorpalBunny"
model.Parent = folder
bunny = model
rig = Rig.bind(model)
-- Without this the client would fall back to the goblin cycle and the
-- Vorpal Bunny would hop like a goblin walks.
Net.setRig(model, "vorpalBunny")
for _, name in { "EyeL", "EyeR" } do
local eye = rig:find(name)
if eye then
table.insert(eyes, eye)
end
end
local body = rig:find("Body")
if body then
trail = Vfx.attachTrail(body, Color3.fromRGB(255, 148, 150))
end
telegraph = Create("Part", {
Name = "Telegraph",
Anchored = true,
CanCollide = false,
CanQuery = false,
Size = Vector3.new(6, 0.12, 1),
Color = Theme.Color.Health,
Material = Enum.Material.Neon,
Transparency = 1,
Parent = folder,
})
marker = Create("Part", {
Name = "TelegraphMarker",
Shape = Enum.PartType.Cylinder,
Anchored = true,
CanCollide = false,
CanQuery = false,
CastShadow = false,
Size = Vector3.new(0.12, 12, 12),
Color = Theme.Color.Health,
Material = Enum.Material.Neon,
Transparency = 1,
Parent = folder,
})
health = ID.maxHealth
engaged = false
introPlayed = false
action = nil
lastAction = nil
animState = "graze"
parryCount = 0
table.clear(aggression)
cacheObstacles()
broadcastState()
end
--------------------------------------------------------------------------------
-- Sequencing
--------------------------------------------------------------------------------
local function startAction(fn, ...)
aborted = false
actionToken += 1
local args = table.pack(...)
action = coroutine.create(function()
fn(ctx, table.unpack(args, 1, args.n))
end)
end
--- The boss intro. It keeps eating until you're close enough to matter.
local function introSequence(_ctx)
local intro = Config.Intro
broadcastImpact("introStart")
for _, player in Players:GetPlayers() do
Network.BossIntro:FireClient(player, "start")
end
ctx.await(intro.graze, "graze")
for _, player in Players:GetPlayers() do
Network.BossIntro:FireClient(player, "silence")
end
ctx.await(intro.silence, "graze")
-- It turns.
ctx.await(intro.turn, "alert", function()
local _, playerPosition = nearestPlayer()
if playerPosition then
ctx.face(playerPosition - position)
end
end)
-- Eyes come up.
Audio.playAt("introStare", position)
setEyeGlow(1)
for _, player in Players:GetPlayers() do
Network.BossIntro:FireClient(player, "glare")
end
ctx.await(intro.glare, "glare")
-- Bar, title, music.
engaged = true
broadcastState()
Audio.startMusic()
Audio.playAt("screech", position)
Vfx.ring(position, 12, Color3.fromRGB(226, 34, 44), 0.5, 0.3)
shakeArena(position, 1.0)
for _, player in Players:GetPlayers() do
Network.BossIntro:FireClient(player, "reveal")
end
ctx.await(intro.reveal, "glare")
setEyeGlow(0)
introPlayed = true
end
--- One decision, then the action that follows from it.
local function combatSequence(_ctx)
local scale = timeScale()
-- It circles while it thinks. There is no standing still.
Actions.circle(ctx, Config.Rest.circleHops, scale)
ctx.await(Brain.restDuration(health / ID.maxHealth) * 0.4, "observe")
local player, playerPosition = nearestPlayer()
if not (player and playerPosition) then
return
end
local now = os.clock()
local recent = 0
for _, stamp in aggression do
if now - stamp <= Config.Utility.aggressionWindow then
recent += 1
end
end
local choice = Brain.choose({
distance = (playerPosition - position).Magnitude,
stamina = Guard.stamina(player),
parries = parryCount,
aggression = recent,
health = health / ID.maxHealth,
last = lastAction,
})
lastAction = choice
local run = Actions[choice]
if run then
run(ctx, scale)
end
end
--------------------------------------------------------------------------------
-- Main loop
--------------------------------------------------------------------------------
RunService.Heartbeat:Connect(function(dt)
if not bunny or not rig then
return
end
-- Hitstop freezes everything: clock, movement, pose. Skipping the frame
-- outright is what makes a hit land rather than merely register.
if os.clock() < hitstopUntil then
return
end
if parryCount > 0 and os.clock() > parryDecayAt then
parryCount = 0
end
-- Knockback decays rather than teleporting.
if knockback.Magnitude > 0.1 then
position += knockback * dt
position = Vector3.new(position.X, groundAt(position.X, position.Z), position.Z)
knockback = knockback:Lerp(Vector3.zero, math.min(dt * 7, 1))
end
local player, playerPosition = nearestPlayer()
local distance = if playerPosition then (playerPosition - position).Magnitude else math.huge
-- Leash.
if engaged and distance > Config.Perception.leash then
engaged = false
health = ID.maxHealth
action = nil
updateTelegraph(false)
updateMarker(false)
Audio.stopMusic()
broadcastState()
end
-- Drive the current action.
if action then
if coroutine.status(action) == "suspended" then
local ok, err = coroutine.resume(action, dt)
if not ok and err ~= ABORT then
warn(`[Encounter] action error: {err}`)
end
if not ok then
action = nil
end
end
if action and coroutine.status(action) == "dead" then
action = nil
end
end
-- Pick the next thing to do. Stagger jumps the queue.
if not action and health > 0 then
if pendingStagger then
pendingStagger = false
lastAction = nil
startAction(Actions.stagger, if staggerDuration > 0 then staggerDuration else GUARD.staggerTime)
elseif not introPlayed then
if player and distance <= Config.Perception.aggroRange then
startAction(introSequence)
else
animState = "graze"
end
elseif engaged and player then
startAction(combatSequence)
elseif player and distance <= Config.Perception.aggroRange then
engaged = true
broadcastState()
Audio.startMusic()
else
animState = "observe"
end
end
-- Head tracking: the single strongest signal that it is watching you.
if playerPosition then
local toPlayer = Motor.flatten(playerPosition - position)
local cross = facing.X * toPlayer.Z - facing.Z * toPlayer.X
local dot = math.clamp(facing:Dot(toPlayer), -1, 1)
lookYaw = math.deg(math.atan2(cross, dot))
else
lookYaw = 0
end
-- lookYaw rides along as a signal: the client needs it to keep the
-- creature's head tracking the player between published states.
Net.publish(bunny, CFrame.lookAt(position, position + facing), animState, animPhase, { lookYaw = lookYaw })
end)
--------------------------------------------------------------------------------
-- Death
--------------------------------------------------------------------------------
local function onDefeated()
engaged = false
action = nil
aborted = true
updateTelegraph(false)
updateMarker(false)
Audio.stopMusic()
Audio.playAt("defeat", position)
Vfx.parryBurst(position + Vector3.new(0, 2, 0))
Vfx.leaves(position, 20)
for _, player in Players:GetPlayers() do
Network.EncounterCleared:FireClient(player, ID.id, ID.rewardXp)
Rewards.grant(player, ID.id, position)
end
broadcastState()
local corpse = bunny
bunny, rig = nil, nil
if corpse then
task.spawn(function()
for _ = 1, 32 do
if not corpse.Parent then
return
end
corpse:PivotTo(corpse:GetPivot() * CFrame.new(0, -0.11, 0))
task.wait(0.03)
end
corpse:Destroy()
end)
Debris:AddItem(corpse, 3)
end
task.delay(RESPAWN_DELAY, spawnBunny)
end
--------------------------------------------------------------------------------
-- Player input
--------------------------------------------------------------------------------
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" then
return
end
local step = Encounters.comboStep(comboIndex)
local now = os.clock()
if attackReadyAt[player] and now < attackReadyAt[player] then
return
end
attackReadyAt[player] = now + (step.windup + step.active) * 0.85
-- A whiffed parry has a real cost: you cannot swing through it.
if Guard.inRecovery(player) then
return
end
table.insert(aggression, now)
if #aggression > 24 then
table.remove(aggression, 1)
end
if not bunny or health <= 0 or not engaged then
return
end
local root = rootOf(player)
if not root then
return
end
local toBunny = position - root.Position
local flat = Vector3.new(toBunny.X, 0, toBunny.Z)
if flat.Magnitude > PLAYER_ATTACK.range then
return
end
local look = Motor.flatten(root.CFrame.LookVector)
local angle = math.deg(math.acos(math.clamp(look:Dot(Motor.flatten(flat)), -1, 1)))
if angle > PLAYER_ATTACK.arc then
return
end
local multiplier = if animState == "stagger"
then GUARD.counter
elseif animState == "recover" or animState == "slashFollow" then GUARD.punish
else 1
local isCrit = math.random() < PLAYER_ATTACK.critChance
local dealt = math.floor(step.damage * multiplier * (if isCrit then PLAYER_ATTACK.critMultiplier else 1))
health = math.max(health - dealt, 0)
knockback = Motor.flatten(position - root.Position) * step.knockback * 6
local heavy = step.knockback >= 30 or multiplier > 1
hitstopUntil = now + (if heavy then HITSTOP.heavy else HITSTOP.light)
local impactAt = position + Vector3.new(0, 2, 0)
Vfx.sparks(impactAt, if heavy then 26 else 12, Color3.fromRGB(255, 214, 160))
Vfx.slash(impactAt, look, if heavy then 8 else 5.5, Color3.fromRGB(255, 236, 200))
Audio.playAt(if heavy then "hitHeavy" else "hitLight", position)
Network.BossDamaged:FireClient(player, dealt, if isCrit or multiplier > 1 then "crit" else "normal", impactAt)
Network.Impact:FireClient(player, if heavy then "heavy" else "light")
broadcastState()
if health <= 0 then
onDefeated()
end
end)
-- Parry, block, dodge and the vitals report are all handled by Combat/Guard,
-- which owns them for every enemy. This script only cares about the creature's
-- own signals, and asks Guard for the player's.
Players.PlayerRemoving:Connect(function(player)
attackReadyAt[player] = nil
end)
Players.PlayerAdded:Connect(function(player)
task.wait(1)
-- Joining players always start with no boss bar; it appears when the
-- encounter engages them.
Network.BossState:FireClient(player, nil)
end)
spawnBunny()
print(`[Encounter] Vorpal Bunny hunting at {World.BunnyArena}`)
]]>
-
Equipment
0
-
Firstia
0
0 and data.root then
local distance = (data.root.Position - root.Position).Magnitude
if distance < bestDistance then
best, bestData, bestDistance = model, data, distance
end
end
end
local enemy = practiceEnemy.model
if enemy and practiceEnemy.health > 0 and enemy.PrimaryPart then
local distance = (enemy.PrimaryPart.Position - root.Position).Magnitude
if distance < bestDistance then
return enemy, practiceEnemy
end
end
return best, bestData
end
--- Dummies route through the same Attack event as real enemies, so the
--- tutorial teaches the real combat system rather than a mock-up of it.
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" then
return
end
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not root then
return
end
local model, data = targetFor(root)
if not (model and data) then
return
end
local step = Encounters.comboStep(comboIndex)
local at = (model.PrimaryPart and model.PrimaryPart.Position or root.Position) + V(0, 4, 0)
data.health -= step.damage
Vfx.sparks(at, if step.knockback >= 30 then 22 else 10, Color3.fromRGB(255, 226, 170))
Vfx.slash(at, root.CFrame.LookVector, 6, Color3.fromRGB(255, 240, 210))
Audio.playAt("hitLight", at)
Network.BossDamaged:FireClient(player, step.damage, "normal", at)
Network.Impact:FireClient(player, if step.knockback >= 30 then "heavy" else "light")
-- "enemyHit" is deliberately not "enemy": the final step completes on the
-- kill, not on the first swing that connects.
Network.TutorialHit:FireClient(player, if model:GetAttribute("PracticeEnemy") then "enemyHit" else "dummy")
if data.health <= 0 then
Vfx.landing(model:GetPivot().Position, 1.2)
if model:GetAttribute("PracticeEnemy") then
Network.TutorialHit:FireClient(player, "enemyDown")
practiceEnemy.model = nil
task.delay(12, function()
-- Comes back so the step can be retried.
populate()
end)
else
dummies[model] = nil
end
model:Destroy()
end
end)
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Drills
--------------------------------------------------------------------------------
--[[
The parry drill: the instructor swings at you on a loop until you get one.
Deliberately gentle. The windup is far longer than anything in the field
(1.0s against the Vorpal Bunny's 0.5s), it telegraphs on the ground, and a
clean hit costs 10 health rather than 92. The lesson is the *timing*, and a
student who dies learning it has learned the wrong thing.
Routed through the same Guard as every real enemy, so what you practise
here is exactly what you will do out there — including that blocking works,
dodging works, and mistiming costs you.
]]
local WINDUP = 1.0
local ACTIVE = 0.22
local REST = 1.5
local REACH = 9
local DRILL_DAMAGE = 10
local drills: { [Player]: string? } = {}
local drillThread: thread? = nil
local function instructorModel(): Model?
if not folder then
return nil
end
for _, child in folder:GetChildren() do
if child:IsA("Model") and child:GetAttribute("Instructor") then
return child
end
end
return nil
end
local function runParryDrill(player: Player)
while drills[player] == "parry" do
local instructor = instructorModel()
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not (instructor and instructor.PrimaryPart and root) then
task.wait(0.5)
continue
end
local origin = instructor.PrimaryPart.Position
local toPlayer = root.Position - origin
local flat = Vector3.new(toPlayer.X, 0, toPlayer.Z)
-- Waits for you to come into range rather than chasing. She is
-- teaching, not hunting.
if flat.Magnitude > REACH + 6 then
Network.TutorialDrill:FireClient(player, "waiting")
task.wait(0.4)
continue
end
-- Ask for the assist first, so the telegraph can be sized to the real
-- time before impact rather than guessing.
local profile = Assist.plan(player)
local total = WINDUP + (if profile then profile.impactDelay else 0)
-- Telegraph that CLOSES on the strike. An expanding ring says
-- "something happened"; a closing one says "now", which is the only
-- thing a parry cue can usefully say.
Network.TutorialDrill:FireClient(player, "windup")
local mark = Vfx.closingRing(origin + V(0, 0.3, 0), REACH, Color3.fromRGB(255, 190, 90), total)
Audio.playAt("growl", origin)
task.wait(WINDUP)
if drills[player] ~= "parry" then
if mark then
mark:Destroy()
end
if profile then
Assist.finish(player, false)
end
return
end
-- She holds the strike at the top of the swing while the client shows
-- the focus effect. The parry window is untouched — this only buys
-- real seconds to react.
if profile then
-- Announced HERE, not when it was planned: the focus ring has to
-- start at the top of the swing, not at the start of the windup.
Assist.announce(player, profile)
-- Compensated: ring + round trip + bias. See Assist.plan.
task.wait(profile.impactDelay)
if drills[player] ~= "parry" then
Assist.finish(player, false)
if mark then
mark:Destroy()
end
return
end
end
-- Swing.
Network.TutorialDrill:FireClient(player, "strike")
Audio.playAt("slash", origin)
Vfx.slash(origin + V(0, 4, 0), flat.Unit, 7, Color3.fromRGB(255, 220, 180))
character = player.Character
root = character and character:FindFirstChild("HumanoidRootPart")
local parried = false
if root and (root.Position - origin).Magnitude <= REACH then
local outcome = Guard.resolve(player, { damage = DRILL_DAMAGE, from = origin })
parried = outcome == "parried"
end
if profile then
Assist.finish(player, parried)
else
Assist.grade(player, parried)
end
task.wait(ACTIVE + REST)
end
end
Network.AssistMode.OnServerEvent:Connect(function(player, mode)
if typeof(mode) == "string" then
Assist.setMode(player, mode)
end
end)
Network.TutorialDrill.OnServerEvent:Connect(function(player, drill)
if drill ~= nil and typeof(drill) ~= "string" then
return
end
drills[player] = drill
if drill == "parry" then
-- Fresh streaks each time the lesson starts.
Assist.reset(player)
end
if drill == "parry" and not drillThread then
drillThread = task.spawn(function()
runParryDrill(player)
drillThread = nil
end)
end
end)
--------------------------------------------------------------------------------
-- Spawn routing
--------------------------------------------------------------------------------
--[[
Origin decides where you wake up. Traveler is dropped on the forest road
with no instruction; everyone else starts inside these walls with an
instructor.
Done by teleport rather than by SpawnLocation teams, because the choice is
made during character creation — after the character has already spawned
somewhere.
]]
Network.OriginChosen.OnServerEvent:Connect(function(player, originId)
if typeof(originId) ~= "string" then
return
end
local target = World.spawnFor(originId)
local facing = if originId == "traveler" then World.FirstiaPosition else World.TrainingYard
local function place(character: Model)
local root = character:FindFirstChild("HumanoidRootPart")
if not root then
return
end
local y = if originId == "traveler" then World.groundHeight(target.X, target.Z) else World.Courtyard.floor
root.CFrame = CFrame.lookAt(V(target.X, y + 5, target.Z), V(facing.X, y + 5, facing.Z))
end
local character = player.Character
if character then
place(character)
end
-- Respawns keep sending you back to your origin's start until the world
-- has real checkpoints.
player.CharacterAdded:Connect(function(newCharacter)
task.wait(0.3)
place(newCharacter)
end)
end)
local function build()
local existing = Workspace:FindFirstChild(FOLDER)
if existing then
existing:Destroy()
end
table.clear(dummies)
folder = Create("Folder", { Name = FOLDER, Parent = Workspace })
buildCourtyard()
populate()
Create("SpawnLocation", {
Name = "CourtyardSpawn",
Anchored = true,
Neutral = true,
Enabled = false, -- routed explicitly by origin, not by Roblox
Size = V(14, 1, 14),
CFrame = CFrame.new(World.CourtyardSpawn + V(0, 0.5, 0)) * CFrame.Angles(0, math.pi, 0),
Color = STONE_DARK,
Material = Enum.Material.Slate,
Transparency = 0.4,
Parent = folder,
})
print(`[Firstia] courtyard ready at {World.Courtyard.center}`)
end
build()
]]>
-
Fishing
0
= 0.8 then "levelUp" else "loot", at)
Profile.addMaterial(player, fish.id, 1)
Network.Loot:FireClient(player, {
id = fish.id,
name = fish.name,
rarity = fish.rarity,
slot = "Fish",
description = fish.description,
quantity = 1,
})
Network.Fishing:FireClient(player, {
state = "caught",
fish = { id = fish.id, name = fish.name, rarity = fish.rarity, value = fish.value },
quality = quality,
grade = label,
})
clearCast(player)
end
--------------------------------------------------------------------------------
Network.Interact.OnServerEvent:Connect(function(player, npcId, action)
if typeof(npcId) ~= "string" or not spots[npcId] then
return
end
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not root then
return
end
-- Range is enforced here as well as on the client, because the client's
-- range check is a convenience and this one is the rule.
if (root.Position - spots[npcId].position).Magnitude > 46 then
return
end
if action ~= "talk" then
return
end
-- One button does both jobs: cast if idle, strike if a line is out. A
-- separate "reel" key would be a key that is wrong to press most of the
-- time.
if casts[player] then
strike(player)
else
beginCast(player, npcId)
end
end)
Players.PlayerRemoving:Connect(clearCast)
--------------------------------------------------------------------------------
local function build()
local existing = Workspace:FindFirstChild(FOLDER)
if existing then
existing:Destroy()
end
table.clear(spots)
folder = Create("Folder", { Name = FOLDER, Parent = Workspace })
for index, z in SPOT_Z do
buildJetty(index, z)
end
print(`[Fishing] {#SPOT_Z} jetties on the river, {#Fishing.Stock} things in it`)
end
build()
]]>
-
Main
0
-
MobGallery
0
-
Profile
count
materials: { [string]: number },
--- itemId -> count (stackables) or 1
items: { [string]: number },
--- questId -> "active" | "done"
quests: { [string]: string },
--- questId -> progress count
questProgress: { [string]: number },
--- mobId -> lifetime kills
kills: { [string]: number },
titles: { [string]: boolean },
visited: { [string]: boolean },
saved: boolean,
}
local profiles: { [Player]: Data } = {}
local function blank(): Data
return {
gold = STARTING_GOLD,
materials = {},
items = {},
quests = {},
questProgress = {},
kills = {},
titles = {},
visited = {},
saved = false,
}
end
--- Fills in anything a stored profile predates, so adding a field here never
--- breaks a save written before it existed.
local function migrate(data): Data
local fresh = blank()
if typeof(data) ~= "table" then
return fresh
end
for key, default in fresh do
if typeof(data[key]) ~= typeof(default) then
data[key] = default
end
end
return data
end
--------------------------------------------------------------------------------
-- Lifecycle
--------------------------------------------------------------------------------
local function load(player: Player)
local data = blank()
if store then
local ok, result = pcall(function()
return store:GetAsync(`p_{player.UserId}`)
end)
if ok then
data = migrate(result)
data.saved = true
else
warn(`[Profile] load failed for {player.Name}: {result}`)
end
end
profiles[player] = data
Profile.push(player)
end
local function save(player: Player)
local data = profiles[player]
if not (store and data) then
return
end
local ok, err = pcall(function()
store:SetAsync(`p_{player.UserId}`, data)
end)
if not ok then
warn(`[Profile] save failed for {player.Name}: {err}`)
end
end
function Profile.get(player: Player): Data?
return profiles[player]
end
--- Sends the whole profile to its owner. Cheap enough to do on every change:
--- it is a handful of small maps, and a client that can never be a frame out
--- of date is one fewer class of bug.
function Profile.push(player: Player)
local data = profiles[player]
if not data then
return
end
Network.Profile:FireClient(player, {
gold = data.gold,
materials = data.materials,
items = data.items,
quests = data.quests,
questProgress = data.questProgress,
kills = data.kills,
titles = data.titles,
persistent = data.saved or store ~= nil,
})
end
--------------------------------------------------------------------------------
-- Currency and goods
--------------------------------------------------------------------------------
function Profile.addGold(player: Player, amount: number)
local data = profiles[player]
if not data or amount <= 0 then
return
end
data.gold += math.floor(amount)
Profile.push(player)
end
--- Returns false and changes nothing if they can't afford it, so callers can
--- treat this as the authorisation check rather than checking separately and
--- racing themselves.
function Profile.spendGold(player: Player, amount: number): boolean
local data = profiles[player]
if not data or amount < 0 or data.gold < amount then
return false
end
data.gold -= amount
Profile.push(player)
return true
end
function Profile.addMaterial(player: Player, id: string, count: number?)
local data = profiles[player]
if not data then
return
end
data.materials[id] = (data.materials[id] or 0) + (count or 1)
Profile.advanceCollect(player, id)
Profile.push(player)
end
--[[
Removes materials and re-syncs any collect quest that wanted them.
The re-sync is the point. Without it you could accept "bring me six hides",
gather six, watch the quest go green, sell all six to the same shopkeeper,
and then click "Hand in" forever — the log still said ready, and the
hand-in failed silently because the materials were gone. Quest progress for
a collect objective has to mean "what is in the bag right now", in both
directions.
]]
function Profile.takeMaterial(player: Player, id: string, count: number): boolean
local data = profiles[player]
if not data or (data.materials[id] or 0) < count then
return false
end
data.materials[id] -= count
if data.materials[id] <= 0 then
data.materials[id] = nil
end
Profile.advanceCollect(player, id)
Profile.push(player)
return true
end
function Profile.addItem(player: Player, id: string, count: number?)
local data = profiles[player]
if not data then
return
end
data.items[id] = (data.items[id] or 0) + (count or 1)
Profile.push(player)
end
function Profile.hasTitle(player: Player, id: string): boolean
local data = profiles[player]
return data ~= nil and data.titles[id] == true
end
function Profile.grantTitle(player: Player, id: string)
local data = profiles[player]
if not data or data.titles[id] then
return
end
data.titles[id] = true
Profile.push(player)
end
--------------------------------------------------------------------------------
-- Quests
--------------------------------------------------------------------------------
function Profile.questState(player: Player, questId: string): string
local data = profiles[player]
if not data then
return "unavailable"
end
return data.quests[questId] or "available"
end
--- A quest is offerable when it isn't already taken and its prerequisite is
--- finished. Prerequisites are single-parent by design — a town this size
--- doesn't need a graph, and a chain is legible in the log.
function Profile.canAccept(player: Player, quest): boolean
local data = profiles[player]
if not data or data.quests[quest.id] then
return false
end
if quest.requires and data.quests[quest.requires] ~= "done" then
return false
end
return true
end
function Profile.accept(player: Player, quest): boolean
local data = profiles[player]
if not (data and Profile.canAccept(player, quest)) then
return false
end
data.quests[quest.id] = "active"
data.questProgress[quest.id] = 0
-- Credit anything already in the bag. Being told to fetch six hides when
-- six hides are in your pocket is the kind of thing that reads as a bug.
if quest.objective.kind == "collect" then
data.questProgress[quest.id] = math.min(data.materials[quest.objective.target] or 0, quest.objective.count)
end
Profile.push(player)
Network.QuestUpdate:FireClient(player, quest.id, "accepted", Profile.progressOf(player, quest))
return true
end
function Profile.progressOf(player: Player, quest): number
local data = profiles[player]
if not data then
return 0
end
return math.min(data.questProgress[quest.id] or 0, quest.objective.count)
end
function Profile.isComplete(player: Player, quest): boolean
return Profile.questState(player, quest.id) == "active"
and Profile.progressOf(player, quest) >= quest.objective.count
end
local function bump(player: Player, quest, amount: number)
local data = profiles[player]
if not data or data.quests[quest.id] ~= "active" then
return
end
local before = data.questProgress[quest.id] or 0
if before >= quest.objective.count then
return
end
local after = math.min(before + amount, quest.objective.count)
data.questProgress[quest.id] = after
Network.QuestUpdate:FireClient(
player,
quest.id,
if after >= quest.objective.count then "ready" else "progress",
after
)
end
--- Called when something dies. Kill counts are lifetime, and separate from
--- quest progress, so a "kill 5" quest taken after 20 goblins still asks for 5.
function Profile.recordKill(player: Player, mobId: string)
local data = profiles[player]
if not data then
return
end
data.kills[mobId] = (data.kills[mobId] or 0) + 1
for _, quest in Town.Quests do
if quest.objective.kind == "kill" and quest.objective.target == mobId then
bump(player, quest, 1)
end
end
Profile.push(player)
end
--- Collect objectives re-read the bag rather than counting deltas, so selling
--- the materials genuinely un-completes the quest instead of leaving it
--- claimable with an empty pack.
function Profile.advanceCollect(player: Player, materialId: string)
local data = profiles[player]
if not data then
return
end
for _, quest in Town.Quests do
if
quest.objective.kind == "collect"
and quest.objective.target == materialId
and data.quests[quest.id] == "active"
then
local held = math.min(data.materials[materialId] or 0, quest.objective.count)
local before = data.questProgress[quest.id] or 0
data.questProgress[quest.id] = held
if held ~= before then
Network.QuestUpdate:FireClient(
player,
quest.id,
if held >= quest.objective.count then "ready" else "progress",
held
)
end
end
end
end
--- Hands in a finished quest. Returns the reward table so the caller can play
--- the celebration, or nil if it wasn't actually finished.
function Profile.turnIn(player: Player, quest)
local data = profiles[player]
if not (data and Profile.isComplete(player, quest)) then
return nil
end
-- Checked, then marked done, then taken — in that order. advanceCollect
-- only re-syncs quests still marked "active", so taking the materials
-- after the state flip can't rewind the progress we just finalised.
if quest.objective.kind == "collect" then
if (data.materials[quest.objective.target] or 0) < quest.objective.count then
return nil
end
end
data.quests[quest.id] = "done"
data.questProgress[quest.id] = quest.objective.count
if quest.objective.kind == "collect" then
Profile.takeMaterial(player, quest.objective.target, quest.objective.count)
end
local reward = quest.reward
if reward.gold then
data.gold += reward.gold
end
if reward.title then
data.titles[reward.title] = true
end
if reward.item then
data.items[reward.item.id] = (data.items[reward.item.id] or 0) + 1
end
Profile.push(player)
Network.QuestUpdate:FireClient(player, quest.id, "done", quest.objective.count)
return reward
end
--------------------------------------------------------------------------------
-- Wiring
--------------------------------------------------------------------------------
Players.PlayerAdded:Connect(function(player)
task.spawn(load, player)
end)
Players.PlayerRemoving:Connect(function(player)
save(player)
profiles[player] = nil
end)
-- Anyone already in (the server script may load after the first join).
for _, player in Players:GetPlayers() do
if not profiles[player] then
task.spawn(load, player)
end
end
task.spawn(function()
while true do
task.wait(AUTOSAVE_SECONDS)
for player in profiles do
save(player)
end
end
end)
game:BindToClose(function()
for player in profiles do
save(player)
end
end)
return Profile
]]>
-
Rabituza
0
-
Rewards
{ gold = {low, high}, drops = { {id, chance, count?} } }
local TABLES = {
goblin = {
gold = { 6, 14 },
drops = {
{ id = "goblin_ear", chance = 0.62 },
{ id = "goblin_iron", chance = 0.34 },
{ id = "beast_hide", chance = 0.22 },
},
},
vorpal_bunny = {
gold = { 620, 880 },
drops = {
{ id = "bunny_fang", chance = 1 },
{ id = "bunny_pelt", chance = 0.85 },
{ id = "beast_hide", chance = 1, count = 3 },
},
},
lycagon = {
gold = { 1250, 1700 },
drops = {
{ id = "wolf_fang", chance = 1 },
{ id = "beast_hide", chance = 1, count = 4 },
},
},
setsuna = {
gold = { 1800, 2300 },
drops = {
{ id = "wolf_fang", chance = 0.4 },
{ id = "bunny_fang", chance = 0.5 },
{ id = "goblin_iron", chance = 1, count = 8 },
{ id = "beast_hide", chance = 1, count = 3 },
},
},
wethermon = {
gold = { 1500, 1950 },
drops = {
{ id = "goblin_iron", chance = 1, count = 6 },
{ id = "beast_hide", chance = 0.5, count = 2 },
},
},
}
--[[
Pays a player for a kill: gold, drops, quest credit and the lifetime count.
`at` is only used for the sparkle, and is optional — a kill credited from
somewhere with no world position still pays.
]]
function Rewards.grant(player: Player, mobId: string, at: Vector3?)
local table_ = TABLES[mobId]
if not table_ then
-- Unknown mob still counts toward quests; it just has nothing to drop.
Profile.recordKill(player, mobId)
return
end
local gold = math.random(table_.gold[1], table_.gold[2])
Profile.addGold(player, gold)
Network.Loot:FireClient(player, {
id = "gold",
name = `{gold} Gold`,
rarity = "Common",
quantity = gold,
description = "Spends anywhere in Firstia.",
})
for _, drop in table_.drops do
if math.random() < drop.chance then
local count = drop.count or 1
local material = Town.Materials[drop.id]
Profile.addMaterial(player, drop.id, count)
Network.Loot:FireClient(player, {
id = drop.id,
name = material and material.name or drop.id,
rarity = material and material.rarity or "Common",
quantity = count,
})
if at then
local rarity = Theme.Rarity[material and material.rarity or "Common"]
Vfx.sparks(at + Vector3.new(0, 2, 0), 8, rarity.Color)
end
end
end
-- Last, so a quest that completes on this kill has its materials already
-- banked when the "objective complete" toast fires.
Profile.recordKill(player, mobId)
end
return Rewards
]]>
-
Roamers
0
0 then
entry.hitstop -= dt
return
end
entry.clock += dt
local player, playerPosition = nearestPlayer(entry.position, if entry.target then LEASH else entry.species.notice)
entry.target = player
-- Head tracking, always, whatever it is doing.
if playerPosition then
local toPlayer = flatten(playerPosition - entry.position)
local cross = entry.facing.X * toPlayer.Z - entry.facing.Z * toPlayer.X
entry.lookYaw = math.deg(math.atan2(cross, math.clamp(entry.facing:Dot(toPlayer), -1, 1)))
else
entry.lookYaw = 0
end
local fleeing = entry.health / entry.species.health <= FLEE_BELOW
if entry.state == "stagger" then
-- A higher parry rank buys a longer opening here too, exactly as it
-- does against the boss. Practising has to teach the real numbers.
if entry.clock >= (entry.staggerFor or 1.4) then
setState(entry, "idle")
end
elseif entry.state == "windup" then
if not entry.committed and entry.clock >= entry.species.windup * COMMIT_AT then
entry.committed = if playerPosition then flatten(playerPosition - entry.position) else entry.facing
Audio.playAt("growl", entry.position)
end
if playerPosition and not entry.committed then
entry.facing = flatten(playerPosition - entry.position)
end
if entry.clock >= entry.species.windup then
entry.struck = false
setState(entry, "thrust")
end
elseif entry.state == "thrust" then
local direction = entry.committed or entry.facing
entry.position += direction * 22 * dt
entry.position = V(entry.position.X, groundAt(entry.position.X, entry.position.Z), entry.position.Z)
if not entry.struck and playerPosition then
local flat = V(playerPosition.X - entry.position.X, 0, playerPosition.Z - entry.position.Z)
if flat.Magnitude <= entry.species.reach then
entry.struck = true
local outcome, staggerScale =
Guard.resolve(player, { damage = entry.species.damage, from = entry.position })
Assist.finish(player, outcome == "parried")
if outcome == "parried" then
entry.staggerFor = 1.4 * (if staggerScale > 0 then staggerScale else 1)
setState(entry, "stagger")
entry.hitstop = Encounters.Hitstop.parry
entry.committed = nil
Vfx.sparks(entry.position + V(0, 4, 0), 20, Color3.fromRGB(255, 240, 200))
return
end
end
end
if entry.clock >= THRUST then
entry.committed = nil
setState(entry, "recover")
end
elseif entry.state == "recover" then
if entry.clock >= entry.species.recover then
entry.rest = REST_MIN + math.random() * (REST_MAX - REST_MIN)
setState(entry, "idle")
end
elseif fleeing and playerPosition then
-- Running. Not bravely.
local away = -flatten(playerPosition - entry.position)
entry.position += away * entry.species.chase * 1.1 * dt
entry.position = V(entry.position.X, groundAt(entry.position.X, entry.position.Z), entry.position.Z)
entry.facing = away
entry.state = "walk"
elseif playerPosition then
-- Engaged: close, then strike when in reach and rested.
local toPlayer = playerPosition - entry.position
local flat = V(toPlayer.X, 0, toPlayer.Z)
entry.facing = flatten(toPlayer)
if flat.Magnitude > entry.species.reach - 1 then
entry.position += entry.facing * entry.species.chase * dt
entry.position = V(entry.position.X, groundAt(entry.position.X, entry.position.Z), entry.position.Z)
entry.state = "walk"
elseif entry.clock >= entry.rest then
entry.committed = nil
setState(entry, "windup")
else
entry.state = "idle"
end
else
-- Unbothered: wanders between points near home.
local toWaypoint = entry.waypoint - entry.position
local flat = V(toWaypoint.X, 0, toWaypoint.Z)
if flat.Magnitude < 4 then
local angle = math.random() * math.pi * 2
local reach = 12 + math.random() * 26
local wx = entry.home.X + math.cos(angle) * reach
local wz = entry.home.Z + math.sin(angle) * reach
entry.waypoint = V(wx, groundAt(wx, wz), wz)
entry.state = "idle"
else
entry.facing = flatten(toWaypoint)
entry.position += entry.facing * entry.species.walk * dt
entry.position = V(entry.position.X, groundAt(entry.position.X, entry.position.Z), entry.position.Z)
entry.state = "walk"
end
end
local phase = if entry.state == "windup" then math.clamp(entry.clock / entry.species.windup, 0, 1) else 0
--[[
Each species animates with its own rig and at its own scale.
`scale` here multiplies the rig's animated squash rather than replacing
it — a dire wolf still stretches into its lunge, it just does all of it
at 42% of a Lycagon's size. Overwriting the animation's scale instead
would give the smaller mobs a rigid, sliding read.
]]
-- Published rather than posed: the client animates and interpolates.
Net.publish(
entry.model,
CFrame.lookAt(entry.position, entry.position + entry.facing),
entry.state,
phase,
{ lookYaw = entry.lookYaw }
)
end
--------------------------------------------------------------------------------
RunService.Heartbeat:Connect(function(dt)
for index = #roamers, 1, -1 do
local entry = roamers[index]
if not entry.model.Parent then
table.remove(roamers, index)
continue
end
local ok, err = pcall(stepOne, entry, dt)
if not ok then
warn(`[Roamers] {err}`)
end
end
end)
--------------------------------------------------------------------------------
-- Taking damage
--------------------------------------------------------------------------------
Network.Attack.OnServerEvent:Connect(function(player, comboIndex)
if typeof(comboIndex) ~= "number" or Guard.inRecovery(player) then
return
end
local root = rootOf(player)
if not root then
return
end
local step = Encounters.comboStep(comboIndex)
local look = flatten(root.CFrame.LookVector)
local best, bestIndex, bestDistance = nil, nil, Encounters.PlayerAttack.range
for index, entry in roamers do
local toEntry = entry.position - root.Position
local flat = V(toEntry.X, 0, toEntry.Z)
if flat.Magnitude >= bestDistance then
continue
end
local angle = math.deg(math.acos(math.clamp(look:Dot(flatten(flat)), -1, 1)))
if angle > Encounters.PlayerAttack.arc then
continue
end
best, bestIndex, bestDistance = entry, index, flat.Magnitude
end
if not best then
return
end
local multiplier = if best.state == "stagger" then COUNTER elseif best.state == "recover" then PUNISH else 1
local crit = math.random() < Encounters.PlayerAttack.critChance
local dealt = math.floor(step.damage * multiplier * (if crit then Encounters.PlayerAttack.critMultiplier else 1))
best.health = math.max(best.health - dealt, 0)
best.hitstop = if step.knockback >= 30 or multiplier > 1 then Encounters.Hitstop.heavy else Encounters.Hitstop.light
best.position += flatten(best.position - root.Position) * step.knockback * 0.06
best.gui.Enabled = true
best.fill.Size = UDim2.fromScale(best.health / best.species.health, 1)
local at = best.position + V(0, 4, 0)
Vfx.sparks(at, if multiplier > 1 then 20 else 9, Color3.fromRGB(255, 226, 170))
Vfx.slash(at, look, 5.5, Color3.fromRGB(255, 240, 210))
Audio.playAt(if multiplier > 1 then "hitHeavy" else "hitLight", best.position)
Network.BossDamaged:FireClient(player, dealt, if crit or multiplier > 1 then "crit" else "normal", at)
Network.Impact:FireClient(player, if multiplier > 1 then "heavy" else "light")
if best.health <= 0 then
Vfx.landing(best.position, 0.9)
Audio.playAt("defeat", best.position)
rollLoot(player, best.position, best.species)
despawn(best, bestIndex)
task.delay(RESPAWN, function()
spawnOne(Random.new(os.clock() * 1000 // 1))
end)
end
end)
--------------------------------------------------------------------------------
local rng = Random.new(World.Seed + 4242)
for _ = 1, COUNT do
spawnOne(rng)
end
print(`[Roamers] {#roamers} goblins in the Rampant Forest`)
]]>
-
Tomb
0
-
Town
0
0.5
--- A door a person walks through, not a cart entrance.
local doorWidth = Scale.DOOR_WIDTH
local function wallPanel(name: string, size: Vector3, offset: Vector3)
local part = slab(name, size, center + offset + V(0, height / 2, 0), PLASTER, Enum.Material.Concrete, model)
part.CanCollide = true
return part
end
if doorOnX then
local side = math.sign(spec.door.X)
-- Solid: the three walls without a door in them.
wallPanel("WallBack", V(wall, height, spec.size.Z), V(-side * half.X, 0, 0))
wallPanel("WallA", V(spec.size.X, height, wall), V(0, 0, -half.Z))
wallPanel("WallB", V(spec.size.X, height, wall), V(0, 0, half.Z))
-- Front, split either side of the doorway.
local panel = (spec.size.Z - doorWidth) / 2
for index = -1, 1, 2 do
wallPanel(`WallFront{index}`, V(wall, height, panel), V(side * half.X, 0, index * (doorWidth + panel) / 2))
end
local lintelHeight = height - Scale.DOORWAY
wallPanel(
"Lintel",
V(wall, lintelHeight, doorWidth),
V(side * half.X, Scale.DOORWAY + lintelHeight / 2 - height / 2, 0)
)
else
local side = math.sign(spec.door.Z)
wallPanel("WallBack", V(spec.size.X, height, wall), V(0, 0, -side * half.Z))
wallPanel("WallA", V(wall, height, spec.size.Z), V(-half.X, 0, 0))
wallPanel("WallB", V(wall, height, spec.size.Z), V(half.X, 0, 0))
local panel = (spec.size.X - doorWidth) / 2
for index = -1, 1, 2 do
wallPanel(`WallFront{index}`, V(panel, height, wall), V(index * (doorWidth + panel) / 2, 0, side * half.Z))
end
local lintelHeight = height - Scale.DOORWAY
wallPanel(
"Lintel",
V(doorWidth, lintelHeight, wall),
V(0, Scale.DOORWAY + lintelHeight / 2 - height / 2, side * half.Z)
)
end
-- Timber framing: two horizontal bands. Costs four parts and does most of
-- the work of making plaster read as a building rather than a box.
for _, y in { height * 0.34, height * 0.72 } do
slab(
"Band",
V(spec.size.X + 0.4, 1.1, spec.size.Z + 0.4),
center + V(0, y, 0),
TIMBER,
Enum.Material.Wood,
model
)
end
-- Roof.
local roofColor = ROOFS[1]
if spec.roof == "hip" then
slab(
"RoofSlab",
V(spec.size.X + 6, 2, spec.size.Z + 6),
center + V(0, height + 1, 0),
roofColor,
Enum.Material.Slate,
model
)
for step = 1, 3 do
local shrink = step * 6
slab(
`RoofStep{step}`,
V(spec.size.X + 6 - shrink, 3, spec.size.Z + 6 - shrink),
center + V(0, height + 1 + step * 3, 0),
roofColor,
Enum.Material.Slate,
model
)
end
else
-- Gable: two wedges meeting at a ridge, aligned across the short axis.
local ridgeAlongX = spec.size.X >= spec.size.Z
local span = if ridgeAlongX then spec.size.Z else spec.size.X
local run = if ridgeAlongX then spec.size.X else spec.size.Z
for index = -1, 1, 2 do
local part = Create("WedgePart", {
Name = `Roof{index}`,
Anchored = true,
Size = V(run + 5, span * 0.45, span / 2 + 3),
Color = roofColor,
Material = Enum.Material.Slate,
Parent = model,
})
local offset = if ridgeAlongX
then V(0, height + span * 0.225 + 0.5, index * (span / 4 + 1.5))
else V(index * (span / 4 + 1.5), height + span * 0.225 + 0.5, 0)
part.CFrame = CFrame.new(center + offset)
* CFrame.Angles(0, math.rad(if ridgeAlongX then 0 else 90), 0)
* CFrame.Angles(0, math.rad(if index < 0 then 180 else 0), 0)
end
end
-- Hanging sign on the door wall, lit at night by its own small light.
local outward = spec.door
local signAt = center
+ outward * (half.X * math.abs(outward.X) + half.Z * math.abs(outward.Z) + 3)
+ V(0, Scale.STOREY * 1.3, 0)
local board = slab(
"Sign",
V(if doorOnX then 1 else 16, 5.5, if doorOnX then 16 else 1),
signAt,
TIMBER,
Enum.Material.Wood,
model
)
Create("SurfaceGui", {
Face = if doorOnX
then (if outward.X > 0 then Enum.NormalId.Right else Enum.NormalId.Left)
else (if outward.Z > 0 then Enum.NormalId.Front else Enum.NormalId.Back),
PixelsPerStud = 26,
LightInfluence = 0,
Parent = board,
Create("TextLabel", {
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = spec.sign,
TextScaled = true,
TextColor3 = spec.accent,
}),
})
Create("PointLight", { Brightness = 1.2, Range = 22, Color = Color3.fromRGB(255, 214, 150), Parent = board })
-- Counter inside, where the shopkeeper stands.
if spec.counter then
local counterAt = center + spec.counter + V(0, Scale.COUNTER / 2, 0)
local counterSize = if doorOnX then V(2.4, Scale.COUNTER, 10) else V(10, Scale.COUNTER, 2.4)
local counter = slab("Counter", counterSize, counterAt, TIMBER, Enum.Material.WoodPlanks, model)
counter.CanCollide = true
end
return model
end
local function buildStreet()
local street = Town.Street
local length = street.fromZ - street.toZ
slab(
"Street",
V(street.halfWidth * 2, 1, length),
V(0, Town.Floor - 0.5, (street.fromZ + street.toZ) / 2),
COBBLE,
Enum.Material.Cobblestone
)
-- Kerbs, so the street has an edge instead of dissolving into the grass.
for side = -1, 1, 2 do
slab(
`Kerb{side}`,
V(2, 1.4, length),
V(side * street.halfWidth, Town.Floor + 0.2, (street.fromZ + street.toZ) / 2),
STONE,
Enum.Material.Slate
)
end
end
local function buildPlaza()
local plaza = Town.Plaza
slab("Plaza", V(plaza.width, 1, plaza.depth), plaza.center + V(0, -0.5, 0), COBBLE, Enum.Material.Cobblestone)
-- Fountain: three stepped rings, water, and a spout. The one place in town
-- that makes noise and moves on its own.
local at = Town.Fountain
slab("FountainBase", V(17, 1, 17), at + V(0, 0.5, 0), STONE, Enum.Material.Marble)
local rim = slab("FountainRim", V(14.5, 1.6, 14.5), at + V(0, 1.4, 0), STONE, Enum.Material.Marble)
rim.CanCollide = true
local water =
slab("FountainWater", V(13, 1.3, 13), at + V(0, 1.45, 0), Color3.fromRGB(88, 158, 178), Enum.Material.Glass)
water.Transparency = 0.4
water.Reflectance = 0.25
slab("FountainStem", V(2.6, 5, 2.6), at + V(0, 4, 0), STONE, Enum.Material.Marble)
slab("FountainBowl", V(7.4, 1, 7.4), at + V(0, 6.8, 0), STONE, Enum.Material.Marble)
slab("FountainBowlLip", V(8.2, 0.5, 8.2), at + V(0, 7.4, 0), STONE_DARK, Enum.Material.Marble)
-- Upper stage and a figure on top. At twelve studs the fountain was lost
-- among the market stalls; it has to be the tallest thing on the plaza or
-- it isn't a centrepiece, it's a bollard.
slab("FountainStem2", V(1.7, 4.5, 1.7), at + V(0, 9.9, 0), STONE, Enum.Material.Marble)
slab("FountainBowl2", V(4.5, 0.8, 4.5), at + V(0, 12.4, 0), STONE, Enum.Material.Marble)
local figure =
slab("FountainFigure", V(1.5, 2.8, 1), at + V(0, 14.2, 0), Color3.fromRGB(206, 200, 184), Enum.Material.Marble)
figure.CFrame = CFrame.new(figure.Position) * CFrame.Angles(0, math.rad(28), 0)
slab("FountainHead", V(0.85, 0.9, 0.85), at + V(0, 16.1, 0), Color3.fromRGB(206, 200, 184), Enum.Material.Marble)
for side = -1, 1, 2 do
local arm = slab(
`FountainArm{side}`,
V(0.5, 2.4, 0.5),
at + V(side * 0.9, 14.9, 0),
Color3.fromRGB(206, 200, 184),
Enum.Material.Marble
)
arm.CFrame = CFrame.new(arm.Position) * CFrame.Angles(0, 0, math.rad(side * 34))
end
-- Four falls from the upper bowl into the basin.
for index = 0, 3 do
local angle = index / 4 * math.pi * 2 + math.pi / 4
local fall = slab(
`Fall{index}`,
V(0.6, 5, 0.6),
at + V(math.cos(angle) * 2.5, 4.2, math.sin(angle) * 2.5),
Color3.fromRGB(178, 220, 232),
Enum.Material.Glass
)
fall.Transparency = 0.55
end
-- Mist off the bowl and a fall from the spout. The plaza's centrepiece is
-- the one thing in town that is genuinely in motion, so it earns particles.
Create("ParticleEmitter", {
Name = "Mist",
Texture = "rbxasset://textures/particles/smoke_main.dds",
Rate = 22,
Lifetime = NumberRange.new(1.4, 2.4),
Speed = NumberRange.new(1, 3),
SpreadAngle = Vector2.new(60, 60),
Size = NumberSequence.new({ NumberSequenceKeypoint.new(0, 1.4), NumberSequenceKeypoint.new(1, 5) }),
Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0.75),
NumberSequenceKeypoint.new(1, 1),
}),
Color = ColorSequence.new(Color3.fromRGB(214, 236, 244)),
Acceleration = Vector3.new(0, 1.5, 0),
LightEmission = 0.6,
Parent = water,
})
Create("Sound", {
Name = "Fountain",
SoundId = "rbxasset://sounds/impact_water.mp3",
Volume = 0.35,
PlaybackSpeed = 0.55,
Looped = true,
RollOffMaxDistance = 120,
RollOffMode = Enum.RollOffMode.InverseTapered,
Parent = water,
}):Play()
-- Stalls around it.
for index, stall in Town.Stalls do
local angle = math.rad(stall.angle)
local stallAt = at + V(math.cos(angle) * stall.radius, 0, math.sin(angle) * stall.radius)
slab(`StallTable{index}`, V(6, 2.6, 3.8), stallAt + V(0, 1.3, 0), TIMBER, Enum.Material.WoodPlanks)
for side = -1, 1, 2 do
slab(`StallPost{index}_{side}`, V(0.4, 6, 0.4), stallAt + V(side * 2.7, 3, 0), TIMBER, Enum.Material.Wood)
end
local canopy =
slab(`StallCanopy{index}`, V(7.4, 0.35, 5.2), stallAt + V(0, 6.2, 0), stall.canopy, Enum.Material.Fabric)
canopy.CFrame = CFrame.new(canopy.Position) * CFrame.Angles(math.rad(-12), 0, 0)
-- Goods on the table: a few small blocks, deterministic per stall.
local rng = Random.new(index * 77)
for crate = 1, 4 do
slab(
`StallGoods{index}_{crate}`,
V(rng:NextNumber(0.6, 1.2), rng:NextNumber(0.5, 1.1), rng:NextNumber(0.6, 1.2)),
stallAt + V(rng:NextNumber(-2.2, 2.2), 3, rng:NextNumber(-1.1, 1.1)),
stall.canopy:Lerp(Color3.new(1, 1, 1), 0.35),
Enum.Material.SmoothPlastic
)
end
end
end
--[[
The bell tower.
Rendering the town from the gate showed a completely flat skyline — twenty
buildings all one storey, nothing to look at and nothing to walk toward.
A town needs one thing taller than everything else: it gives the silhouette
a peak, it tells you which way the centre is from anywhere inside the
walls, and it is the difference between a place and a housing estate.
]]
local function buildTower()
local at = V(48, 0, -706)
local rng = Random.new(777)
-- Battered base: three shrinking stages, so it tapers instead of being a
-- 70-stud column dropped on the grass.
-- Slimmer than the first pass: at 22 studs across it read as a factory
-- chimney beside twenty-stud houses. A bell tower is tall, not fat.
local stages = { { 13, 16 }, { 11, 14 }, { 9, 12 } }
local y = 0
for index, stage in stages do
local width, height = stage[1], stage[2]
local part = slab(
`TowerStage{index}`,
V(width, height, width),
at + V(0, y + height / 2, 0),
Detail.vary(STONE, rng, 0.03),
Enum.Material.Brick
)
part.CanCollide = true
-- String course between stages: a shadow line every 20-odd studs is
-- what stops a tall thing reading as one extruded block.
slab(
`TowerCourse{index}`,
V(width + 1.4, 0.9, width + 1.4),
at + V(0, y + height, 0),
STONE_DARK,
Enum.Material.Slate
)
y += height
end
-- Belfry: open arches on all four sides.
for side = -1, 1, 2 do
slab(`TowerPierX{side}`, V(2, 9, 2), at + V(side * 3.6, y + 4.5, -3.6), STONE, Enum.Material.Brick)
slab(`TowerPierZ{side}`, V(2, 9, 2), at + V(side * 3.6, y + 4.5, 3.6), STONE, Enum.Material.Brick)
end
slab("BelfryFloor", V(10.5, 0.9, 10.5), at + V(0, y + 0.45, 0), STONE_DARK, Enum.Material.Slate)
slab("BelfryCap", V(11.8, 1.4, 11.8), at + V(0, y + 9.6, 0), STONE_DARK, Enum.Material.Slate)
-- The bell itself, and a light in the belfry so the tower reads at night.
local bell = slab("Bell", V(3, 3.6, 3), at + V(0, y + 5.6, 0), Color3.fromRGB(150, 118, 62), Enum.Material.Metal)
bell.Shape = Enum.PartType.Ball
Create("PointLight", {
Brightness = 0,
Range = 44,
Color = Color3.fromRGB(255, 208, 150),
Parent = bell,
})
table.insert(lanterns, { light = bell:FindFirstChildOfClass("PointLight"), bulb = bell })
-- Spire: stacked shrinking blocks read as a taper at this scale and cost
-- eight parts instead of a mesh.
local spireBase = y + 10.4
for index = 0, 7 do
local t = index / 8
slab(
`Spire{index}`,
V(10.5 * (1 - t) + 0.8, 2.6, 10.5 * (1 - t) + 0.8),
at + V(0, spireBase + index * 2.6 + 1.3, 0),
ROOFS[1],
Enum.Material.Slate
)
end
slab("SpireTip", V(0.9, 4.4, 0.9), at + V(0, spireBase + 22, 0), Color3.fromRGB(198, 168, 96), Enum.Material.Metal)
-- Clock face on the side that looks down the street.
local face = slab(
"ClockFace",
V(0.8, 5.4, 5.4),
at + V(-6.8, spireBase - 10, 0),
Color3.fromRGB(232, 226, 208),
Enum.Material.Marble
)
Create("PointLight", { Brightness = 0, Range = 20, Color = Color3.fromRGB(255, 226, 180), Parent = face })
table.insert(lanterns, { light = face:FindFirstChildOfClass("PointLight"), bulb = face })
end
local function buildHouses()
for index, house in Town.Houses do
local color = if index % 2 == 0 then PLASTER else STONE
-- Sunk half a stud so the base meets the grass plate rather than
-- hovering over it. Houses stand on the ground plate, not on paving, so
-- dropping that plate to -0.35 left every one of them floating.
local body = slab(
`House{index}`,
V(house.size.X, house.size.Y, house.size.Z),
house.at + V(0, house.size.Y / 2 - 0.5, 0),
color,
Enum.Material.Concrete
)
body.CanCollide = true
slab(
`HouseBand{index}`,
V(house.size.X + 0.3, 1, house.size.Z + 0.3),
house.at + V(0, house.size.Y * 0.55, 0),
TIMBER,
Enum.Material.Wood
)
local roof = Create("WedgePart", {
Name = `HouseRoof{index}`,
Anchored = true,
Size = V(house.size.X + 4, house.size.Z * 0.5, house.size.Z + 4),
Color = ROOFS[house.tint],
Material = Enum.Material.Slate,
Parent = folder,
})
roof.CFrame = CFrame.new(house.at + V(0, house.size.Y + house.size.Z * 0.25, 0)) * CFrame.Angles(0, 0, 0)
local roofBack = roof:Clone()
roofBack.CFrame = roof.CFrame * CFrame.Angles(0, math.rad(180), 0)
roofBack.Parent = folder
-- Framed windows with shutters and a flower box, rather than a dark
-- rectangle stuck to the wall. Same part budget, entirely different read.
local rng = Random.new(index * 4099)
for side = -1, 1, 2 do
local at = house.at + V(side * house.size.X * 0.26, house.size.Y * 0.6, house.size.Z / 2)
local _, light = Detail.window(CFrame.lookAt(at, at + V(0, 0, 1)), rng, {
parent = folder,
width = 3.6,
height = 4.6,
shutters = true,
shutterColor = ROOFS[house.tint],
})
table.insert(lanterns, { light = light, bulb = light.Parent })
local boxAt = at - V(0, 3.4, 0) + V(0, 0, 1.4)
Detail.flowerBox(CFrame.lookAt(boxAt, boxAt + V(0, 0, 1)), rng, folder)
end
Detail.chimney(
CFrame.new(house.at + V(house.size.X * 0.28, house.size.Y + 1, -house.size.Z * 0.2)),
rng,
folder
)
end
end
local function buildLanterns()
for index, at in Town.Lanterns do
slab(`LanternPost{index}`, V(0.5, 8, 0.5), at + V(0, 4, 0), Color3.fromRGB(52, 50, 48), Enum.Material.Metal)
slab(
`LanternArm{index}`,
V(1.4, 0.35, 0.35),
at + V(0, 7.8, 0),
Color3.fromRGB(52, 50, 48),
Enum.Material.Metal
)
local bulb = slab(
`Lantern{index}`,
V(2.4, 3, 2.4),
at + V(0, 12.6, 0),
Color3.fromRGB(255, 226, 176),
Enum.Material.Neon
)
bulb.Transparency = 0.15
local light = Create("PointLight", {
Brightness = 0,
Range = 34,
Color = Color3.fromRGB(255, 206, 150),
Parent = bulb,
})
table.insert(lanterns, { light = light, bulb = bulb })
end
end
local function buildWalls()
-- Outer wall around the whole town, so the place is enclosed rather than
-- five buildings on an infinite plain. Gap at the south, where the
-- courtyard arch already is.
local minX, maxX = -160, 160
local minZ, maxZ = -770, -505
local height = 30
-- East wall is solid. The west wall opens for the Colosseum causeway, so
-- the arena is somewhere you walk out to rather than somewhere you appear.
local east = slab(
"TownWallE",
V(5, height, maxZ - minZ),
V(maxX, height / 2, (minZ + maxZ) / 2),
STONE_DARK,
Enum.Material.Brick
)
east.CanCollide = true
local gate = Town.Colosseum
for side = -1, 1, 2 do
local edge = if side < 0 then minZ else maxZ
local panelDepth = math.abs(edge - (gate.gateZ + side * gate.gateWidth / 2))
local part = slab(
`TownWallW{side}`,
V(5, height, panelDepth),
V(minX, height / 2, (edge + gate.gateZ + side * gate.gateWidth / 2) / 2),
STONE_DARK,
Enum.Material.Brick
)
part.CanCollide = true
end
slab("WestGateLintel", V(5, 7, gate.gateWidth + 4), V(minX, height - 3.5, gate.gateZ), STONE, Enum.Material.Brick)
local north =
slab("TownWallN", V(maxX - minX + 5, height, 5), V(0, height / 2, minZ), STONE_DARK, Enum.Material.Brick)
north.CanCollide = true
-- South wall, split around the street so the courtyard arch leads through.
local gap = Town.Street.halfWidth * 2 + 6
for side = -1, 1, 2 do
local panelWidth = (maxX - minX - gap) / 2
local part = slab(
`TownWallS{side}`,
V(panelWidth, height, 5),
V(side * (gap + panelWidth) / 2, height / 2, maxZ),
STONE_DARK,
Enum.Material.Brick
)
part.CanCollide = true
end
--[[
Ground plate under the whole town, so nothing sits on generated terrain.
ITS TOP FACE IS BELOW THE PAVING, and that is the entire point. It used
to sit at y = 0 — exactly the height of the plaza slab, the street slab
and the courtyard floor, all of which lie directly on top of it. Four
coplanar surfaces covering every square stud anyone walks on in Firstia,
which is around twenty thousand studs of z-fighting: the grass and the
cobbles flickering against each other across the whole town, changing
with the camera angle. It is the single ugliest thing in the game and it
is exactly what rule 6 in the handoff was written about.
0.35 below is the same relationship the handoff describes — paved plaza
above grass — and it is small enough to read as a kerb rather than a
step.
]]
slab(
"TownGround",
V(maxX - minX + 40, 2, maxZ - minZ + 40),
V(0, -1.35, (minZ + maxZ) / 2),
Color3.fromRGB(96, 104, 76),
Enum.Material.Grass
)
end
--------------------------------------------------------------------------------
-- Interiors
--------------------------------------------------------------------------------
--[[
What is actually inside each shop.
A room with a counter is a room. A room with a lit forge, an anvil, a rack
of blades and three barrels is a smithy — and the difference is entirely
props, because the shell is the same six boxes either way. Offsets are
relative to the building centre; the buildings are axis-aligned so no
rotation is needed.
Each entry is a list of {kind, at, rot?, extra?}. Fires register their light
so the night pass can pulse them.
]]
local INTERIORS = {
smithy = {
{ kind = "fire", at = V(-9.2, 0, -8.6), scale = 1.6 },
{ kind = "anvil", at = V(-1.3, 0, -7.9) },
{ kind = "weaponRack", at = V(0.0, 0, 9.9), face = V(0, 0, -1) },
{ kind = "barrel", at = V(-9.9, 0, 9.2) },
{ kind = "barrel", at = V(-7.3, 0, 10.6) },
{ kind = "crate", at = V(1.3, 0, 9.9) },
{ kind = "shelf", at = V(-11.9, 0, 2.6), face = V(1, 0, 0), jar = Color3.fromRGB(150, 150, 158) },
},
apothecary = {
{ kind = "shelf", at = V(9.9, 0, -7.3), face = V(-1, 0, 0), jar = Color3.fromRGB(120, 192, 140) },
{ kind = "shelf", at = V(9.9, 0, 4.0), face = V(-1, 0, 0), jar = Color3.fromRGB(196, 148, 208) },
{ kind = "shelf", at = V(0.0, 0, -8.6), face = V(0, 0, 1), jar = Color3.fromRGB(226, 184, 110) },
{ kind = "fire", at = V(8.6, 0, 7.9), scale = 0.7 },
{ kind = "sack", at = V(2.6, 0, 8.6) },
{ kind = "sack", at = V(4.6, 0, 9.2) },
},
general = {
{ kind = "shelf", at = V(-10.6, 0, -7.9), face = V(1, 0, 0), jar = Color3.fromRGB(180, 160, 120) },
{ kind = "crate", at = V(-9.2, 0, 7.9) },
{ kind = "crate", at = V(-5.9, 0, 9.2) },
{ kind = "crate", at = V(-8.6, 0, 10.6) },
{ kind = "sack", at = V(1.3, 0, 8.6) },
{ kind = "sack", at = V(3.3, 0, 9.9) },
{ kind = "barrel", at = V(-10.6, 0, 5.3) },
{ kind = "cart", at = V(4.0, 0, -7.9) },
},
guild = {
{ kind = "questBoard", at = V(0.0, 0, -11.9), face = V(0, 0, 1) },
{ kind = "table", at = V(-5.9, 0, 1.3) },
{ kind = "table", at = V(-5.9, 0, 9.2) },
{ kind = "fire", at = V(10.6, 0, 9.9), scale = 1.1 },
{ kind = "shelf", at = V(13.2, 0, -5.3), face = V(-1, 0, 0), jar = Color3.fromRGB(140, 168, 200) },
{ kind = "barrel", at = V(9.2, 0, -10.6) },
},
tavern = {
{ kind = "fire", at = V(-13.9, 0, -6.6), scale = 1.3 },
{ kind = "table", at = V(-7.9, 0, 4.0) },
{ kind = "table", at = V(7.9, 0, 4.0) },
{ kind = "table", at = V(0.0, 0, -4.0) },
{ kind = "shelf", at = V(13.2, 0, -7.3), face = V(-1, 0, 0), jar = Color3.fromRGB(198, 148, 92) },
{ kind = "barrel", at = V(11.9, 0, 6.6) },
{ kind = "barrel", at = V(14.5, 0, 4.6) },
},
}
--- Builds one interior. `rng` is seeded per building so the dressing is the
--- same every run — a shop that rearranges itself on each server start is
--- disorienting in a way nobody can name.
local function dressInterior(spec, model: Model)
local list = INTERIORS[spec.id]
if not list then
return
end
local rng = Random.new(spec.center.X * 31 + spec.center.Z)
for _, prop in list do
local at = spec.center + prop.at
local face = prop.face or V(0, 0, -1)
local origin = CFrame.lookAt(at, at + face)
if prop.kind == "fire" then
local _, light = Detail.fire(origin, rng, { scale = prop.scale, parent = model })
-- Registered like a lantern so the night pass can breathe it.
table.insert(fires, light)
elseif prop.kind == "shelf" then
Detail.shelf(origin, rng, { parent = model, jarColor = prop.jar })
elseif prop.kind == "anvil" then
Detail.anvil(origin, rng, model)
elseif prop.kind == "weaponRack" then
Detail.weaponRack(origin, rng, model)
elseif prop.kind == "questBoard" then
Detail.questBoard(origin, rng, model)
elseif prop.kind == "table" then
Detail.table(origin, rng, model)
elseif prop.kind == "barrel" then
Detail.barrel(origin, rng, model)
elseif prop.kind == "crate" then
Detail.crate(origin, rng, model)
elseif prop.kind == "sack" then
Detail.sack(origin, rng, model)
elseif prop.kind == "cart" then
Detail.cart(origin, rng, model)
end
end
end
--[[
Exterior dressing: the doorway, its windows, and a smoking chimney.
Windows go on the two walls perpendicular to the door, never on the door
wall itself — a facade with a door and two windows crammed into the same
twelve studs reads as a dollhouse. The chimney is what sells the roofline
from across the plaza, because its smoke is the only thing up there that
moves.
]]
local function dressExterior(spec, model: Model)
local rng = Random.new(spec.center.X * 17 + spec.center.Z * 3)
local half = spec.size * 0.5
local doorOnX = math.abs(spec.door.X) > 0.5
local doorAt = spec.center + V(spec.door.X * half.X, 0, spec.door.Z * half.Z)
local _, doorLight = Detail.doorframe(CFrame.lookAt(doorAt, doorAt + spec.door), rng, {
parent = model,
width = Scale.DOOR_WIDTH,
height = Scale.DOORWAY,
})
-- The bulb is always the light's own parent: for a doorway that's the neon
-- lamp, for a window it's the glass pane. Naming the part separately is how
-- you end up tinting a signboard instead of a window.
table.insert(lanterns, { light = doorLight, bulb = doorLight.Parent })
-- Windows on the two walls the door isn't in.
for side = -1, 1, 2 do
local normal = if doorOnX then V(0, 0, side) else V(side, 0, 0)
local wallAt = spec.center + V(normal.X * half.X, 0, normal.Z * half.Z)
local along = if doorOnX then V(1, 0, 0) else V(0, 0, 1)
local span = if doorOnX then spec.size.X else spec.size.Z
for slot = -1, 1, 2 do
local at = wallAt + along * (slot * span * 0.24) + V(0, spec.size.Y * 0.56, 0)
local _, light = Detail.window(CFrame.lookAt(at, at + normal), rng, {
parent = model,
shutters = true,
shutterColor = spec.accent,
})
table.insert(lanterns, { light = light, bulb = light.Parent })
-- Flower box under the ground-floor windows, on the street side only.
if slot == 1 then
local boxAt = at - V(0, spec.size.Y * 0.52 - 4.2, 0) + normal * 1.4
Detail.flowerBox(CFrame.lookAt(boxAt, boxAt + normal), rng, model)
end
end
end
Detail.chimney(CFrame.new(spec.center + V(half.X * 0.45, spec.size.Y + 1, half.Z * 0.4)), rng, model)
end
--[[
Street furniture.
Deliberately clustered rather than spread: goods pile up beside the door
they came out of, carts stop where there is room to turn, and a fence only
exists where there is something to keep out. Evenly-distributed props read
as decoration; clustered ones read as consequences.
]]
local function dressStreets()
local rng = Random.new(90210)
-- Goods stacked outside each shop door.
for _, spec in Town.Buildings do
local half = spec.size * 0.5
local outside = spec.center + V(spec.door.X * (half.X + 9), 0, spec.door.Z * (half.Z + 9))
local along = if math.abs(spec.door.X) > 0.5 then V(0, 0, 1) else V(1, 0, 0)
for index = 1, rng:NextInteger(3, 5) do
local at = outside + along * rng:NextNumber(-11, 11) + V(rng:NextNumber(-2, 2), 0, rng:NextNumber(-2, 2))
local roll = rng:NextNumber()
if roll < 0.4 then
Detail.barrel(CFrame.new(at), rng, folder)
elseif roll < 0.75 then
Detail.crate(CFrame.new(at), rng, folder)
else
Detail.sack(CFrame.new(at), rng, folder)
end
if index == 1 then
-- One crate gets stacked on another. Free verticality.
Detail.crate(CFrame.new(at + V(0.4, 3.4, 0.3)), rng, folder)
end
end
end
-- Banners flanking the street, in the town's blue.
for _, z in { -534, -580 } do
for side = -1, 1, 2 do
Detail.banner(
CFrame.lookAt(V(side * 26, 0, z), V(side * 26, 0, z) + V(-side, 0, 0)),
rng,
Color3.fromRGB(62, 120, 148),
folder
)
end
end
-- Carts parked around the plaza.
for _, at in { V(-46, 0, -614), V(40, 0, -620), V(-52, 0, -712) } do
Detail.cart(CFrame.new(at), rng, folder)
end
-- Fences enclosing the two back gardens.
Detail.fence(CFrame.new(V(-104, 0, -578)), rng, 34, folder)
Detail.fence(CFrame.lookAt(V(122, 0, -668), V(123, 0, -668)), rng, 30, folder)
end
--------------------------------------------------------------------------------
-- People
--------------------------------------------------------------------------------
local function buildFigure(npc): Model
local ctx = Build.begin(npc.id, CFrame.new())
--[[
FIGURE_SCALE brings the hand-authored 9-stud proportions down to a
Roblox humanoid. The offsets below stay as authored so the figure's
proportions are still readable in the source; only the ruler changes.
]]
local s = (npc.scale or 1) * Scale.fromOldFigure(1)
local cloth, skin, hair = npc.cloth, npc.skin, npc.hair
local function sv(x: number, y: number, z: number)
return V(x * s, y * s, z * s)
end
ctx:pair("block", { name = "Boot", size = sv(1.1, 0.9, 1.6), at = sv(0.62, 0.45, -0.1), color = TIMBER })
ctx:pair(
"block",
{ name = "Leg", size = sv(1.0, 2.4, 1.05), at = sv(0.62, 2.0, 0), color = cloth:Lerp(Color3.new(), 0.3) }
)
ctx:block({ name = "Hips", size = sv(2.5, 1.0, 1.4), at = sv(0, 3.5, 0), color = cloth:Lerp(Color3.new(), 0.3) })
ctx:block({ name = "Belt", size = sv(2.7, 0.5, 1.5), at = sv(0, 4.0, 0), color = TIMBER })
ctx:block({ name = "Torso", size = sv(2.8, 2.7, 1.55), at = sv(0, 5.5, 0), color = cloth })
ctx:block({
name = "Collar",
size = sv(3.0, 0.45, 1.75),
at = sv(0, 6.8, 0),
color = cloth:Lerp(Color3.new(), 0.25),
})
ctx:pair("block", { name = "Arm", size = sv(0.9, 2.5, 0.95), at = sv(1.82, 5.4, 0), color = cloth })
ctx:pair("block", { name = "Hand", size = sv(0.95, 0.85, 1.0), at = sv(1.84, 3.95, 0), color = skin })
ctx:block({ name = "Neck", size = sv(0.85, 0.55, 0.85), at = sv(0, 7.2, 0), color = skin })
ctx:block({ name = "Head", size = sv(1.5, 1.6, 1.5), at = sv(0, 8.15, 0), color = skin })
ctx:block({ name = "Hair", size = sv(1.62, 0.8, 1.62), at = sv(0, 8.8, 0), color = hair })
ctx:block({ name = "HairBack", size = sv(1.55, 1.1, 0.5), at = sv(0, 8.2, 0.6), color = hair })
ctx:pair(
"block",
{ name = "Eye", size = sv(0.18, 0.2, 0.12), at = sv(0.34, 8.25, -0.76), color = Color3.fromRGB(32, 30, 34) }
)
return ctx:finishRigged()
end
local function nameplate(model: Model, npc)
Create("BillboardGui", {
Name = "Nameplate",
Size = UDim2.fromOffset(240, 44),
StudsOffsetWorldSpace = V(0, 6.4 * (npc.scale or 1), 0),
MaxDistance = 110,
LightInfluence = 0,
Parent = model.PrimaryPart,
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = npc.name,
TextSize = 16,
TextColor3 = Theme.Color.Text,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.3,
}),
Create("TextLabel", {
Name = "Title",
Position = UDim2.fromOffset(0, 22),
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = npc.title,
TextSize = 12,
TextColor3 = if npc.role == "quest" then Theme.Color.Unique else Theme.Color.TextMuted,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.45,
}),
})
end
local function spawnResidents()
for _, npc in Town.Npcs do
local entry = Town.scheduleAt(npc, Lighting.ClockTime)
local at = entry.at + V(0, Town.Floor, 0)
-- Most residents are the shared human figure; `build` opts one out to a
-- model from the Mobs catalogue instead.
local model = if npc.build then Mobs.build(npc.build, CFrame.new()) else buildFigure(npc)
if not model then
warn(`[Town] {npc.id} names an unknown model "{npc.build}"; skipped`)
continue
end
model.Name = npc.id
model.Parent = folder
model:SetAttribute("NpcId", npc.id)
model:SetAttribute("NpcName", npc.name)
model:SetAttribute("NpcTitle", npc.title)
model:SetAttribute("Interactable", true)
nameplate(model, npc)
--[[
No rig bound here. The client owns posing; the server owns where
this person is considered to be and what they will say.
The model is still placed once at spawn so it is not sitting at the
origin for the frame before a client picks it up.
]]
local resident = {
npc = npc,
model = model,
position = at,
lineIndex = 0,
state = entry.state,
}
model:PivotTo(CFrame.lookAt(at, at + entry.facing))
residents[npc.id] = resident
end
end
--------------------------------------------------------------------------------
-- The day
--------------------------------------------------------------------------------
--[[
Where each resident is, for range checks only.
The server no longer poses anyone — Controllers/Townsfolk does that on
every client at frame rate, because anchored-part CFrames do not
interpolate across the network and posing fifteen rigs server-side made the
whole town judder at the replication rate.
What the server still needs is an authoritative answer to "is the player
close enough to talk to this person", and that comes from the same pure
`Town.scheduleAt` the clients use. Both halves therefore agree without
anything being sent.
Walking is integrated rather than snapped so the server's idea of a
resident tracks the client's during the walk home, not just at the ends.
]]
local function driveResidents(dt: number)
local hour = Lighting.ClockTime
for _, resident in residents do
local entry = Town.scheduleAt(resident.npc, hour)
local target = entry.at + V(0, Town.Floor, 0)
local delta = target - resident.position
local distance = delta.Magnitude
if distance > 1.2 then
resident.position += delta.Unit * math.min(WALK_SPEED * dt, distance)
else
resident.position = target
end
resident.state = entry.state
end
end
--- Lanterns and windows come up as the sun goes down. Eased rather than
--- switched: a town that snaps to full brightness on one frame reads as a
--- light switch, not a lamplighter.
local function driveLights(dt: number)
local hour = Lighting.ClockTime
local dark = Sky.isNight(hour) or hour < 6.2 or hour > 18.4
local target = if dark then 1 else 0
-- Hearths breathe rather than burn flat. A fire whose light does not move
-- reads as a lamp painted orange.
local flicker = math.sin(os.clock() * 5.3) * 0.22 + math.sin(os.clock() * 11.7) * 0.11
for _, fire in fires do
fire.Brightness = 2.6 + flicker
end
for _, lamp in lanterns do
if not lamp.bulb then
continue
end
local current = lamp.light:GetAttribute("Level") or 0
local next = current + (target - current) * math.clamp(dt * 1.5, 0, 1)
lamp.light:SetAttribute("Level", next)
lamp.light.Brightness = next * 2.2
if lamp.bulb.Material == Enum.Material.Neon then
lamp.bulb.Transparency = 0.15 + (1 - next) * 0.5
else
lamp.bulb.Color = Color3.fromRGB(48, 44, 40):Lerp(Color3.fromRGB(255, 210, 150), next)
end
end
end
--------------------------------------------------------------------------------
-- Interaction
--------------------------------------------------------------------------------
local function rootOf(player: Player): BasePart?
local character = player.Character
return character and character:FindFirstChild("HumanoidRootPart") :: BasePart?
end
local function inRange(player: Player, resident): boolean
local root = rootOf(player)
if not root then
return false
end
return (root.Position - resident.position).Magnitude <= TALK_RANGE + 6
end
--- The line this NPC says right now: time-of-day band first, then rotating
--- through that band's lines so a second press isn't the same sentence.
local function lineFor(resident): string
local band = Town.band(Lighting.ClockTime)
local lines = resident.npc.lines[band] or resident.npc.lines.day
resident.lineIndex += 1
return lines[(resident.lineIndex - 1) % #lines + 1]
end
--- Everything the player can be offered by this person, as buttons.
local function optionsFor(player: Player, resident)
local npc = resident.npc
local options = {}
if npc.role == "shop" then
local open = resident.state == "work"
table.insert(options, {
id = "shop",
label = if open then "Browse wares" else "Shop is closed",
enabled = open,
})
elseif npc.role == "rest" then
table.insert(options, { id = "rest", label = "Rest (20g)", enabled = true })
elseif npc.role == "heal" then
table.insert(options, { id = "heal", label = "Ask for healing", enabled = true })
elseif npc.role == "craft" then
table.insert(options, { id = "craft", label = "Use the bench", enabled = resident.state == "work" })
elseif npc.role == "arena" then
table.insert(options, { id = "arena", label = "Enter the Colosseum", enabled = true, highlight = true })
end
-- Quests they own, in whatever state you have them.
for _, quest in Town.questsFrom(npc.id) do
local state = Profile.questState(player, quest.id)
if state == "active" then
local complete = Profile.isComplete(player, quest)
table.insert(options, {
id = if complete then `turnin:{quest.id}` else `about:{quest.id}`,
label = if complete then `Hand in: {quest.name}` else `About: {quest.name}`,
enabled = true,
highlight = complete,
})
elseif state == "available" and Profile.canAccept(player, quest) then
table.insert(options, {
id = `offer:{quest.id}`,
label = `New work: {quest.name}`,
enabled = true,
highlight = true,
})
end
end
table.insert(options, { id = "close", label = "Leave", enabled = true })
return options
end
local function say(player: Player, resident, text: string, options)
Network.Dialogue:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
title = resident.npc.title,
text = text,
options = options or optionsFor(player, resident),
})
end
local function openShop(player: Player, resident)
local shop = Town.Shops[resident.npc.shop]
if not shop then
return
end
local data = Profile.get(player)
local sellable = {}
if data then
for id, count in data.materials do
local material = Town.Materials[id]
if material and count > 0 then
table.insert(sellable, {
id = id,
name = material.name,
rarity = material.rarity,
count = count,
price = Town.SellValues[id] or 10,
})
end
end
end
Network.Shop:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
shopName = Town.findBuilding(resident.npc.shop) and Town.findBuilding(resident.npc.shop).name or shop.greeting,
greeting = shop.greeting,
stock = shop.stock,
sellable = sellable,
gold = if data then data.gold else 0,
})
end
local ACTIONS = {}
function ACTIONS.talk(player: Player, resident)
Audio.playAt("uiSelect", resident.position)
say(player, resident, lineFor(resident))
end
function ACTIONS.shop(player: Player, resident)
if resident.state ~= "work" then
say(player, resident, "Come back when I'm open.")
return
end
openShop(player, resident)
end
function ACTIONS.rest(player: Player, resident)
if not Profile.spendGold(player, 20) then
say(player, resident, "Twenty gold. I know, I know.")
return
end
Network.Dialogue:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
title = resident.npc.title,
text = "Upstairs, second on the left. Don't bleed on the sheets.",
effect = "rest",
options = { { id = "close", label = "Sleep", enabled = true } },
})
end
function ACTIONS.heal(player: Player, resident)
Network.Dialogue:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
title = resident.npc.title,
text = "Hold still. There — the water does the work, I only ask it nicely.",
effect = "heal",
options = { { id = "close", label = "Thank her", enabled = true } },
})
Vfx.sparks(resident.position + V(0, 5, 0), 18, Theme.Color.Heal)
Audio.playAt("levelUp", resident.position)
end
function ACTIONS.buy(player: Player, resident, itemId: string)
local shop = Town.Shops[resident.npc.shop]
if not (shop and resident.state == "work") then
return
end
for _, item in shop.stock do
if item.id == itemId then
if not Profile.spendGold(player, item.price) then
Network.Dialogue:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
title = resident.npc.title,
text = "Not for that, you don't.",
options = { { id = "close", label = "Right", enabled = true } },
})
return
end
Profile.addItem(player, item.id, 1)
Network.Loot:FireClient(player, {
id = item.id,
name = item.name,
rarity = item.rarity,
slot = item.slot,
description = item.description,
stats = item.stats,
quantity = 1,
})
Audio.playAt("loot", resident.position)
openShop(player, resident)
return
end
end
end
function ACTIONS.sell(player: Player, resident, materialId: string)
local value = Town.SellValues[materialId]
if not (value and resident.state == "work") then
return
end
if Profile.takeMaterial(player, materialId, 1) then
Profile.addGold(player, value)
Audio.playAt("uiSelect", resident.position)
openShop(player, resident)
end
end
function ACTIONS.offer(player: Player, resident, questId: string)
local quest = Town.findQuest(questId)
if not quest then
return
end
say(player, resident, quest.summary, {
{ id = `accept:{quest.id}`, label = "Take the job", enabled = true, highlight = true },
{ id = "talk", label = "Not right now", enabled = true },
})
end
function ACTIONS.accept(player: Player, resident, questId: string)
local quest = Town.findQuest(questId)
if not (quest and Profile.accept(player, quest)) then
return
end
Audio.playAt("unique", resident.position)
say(player, resident, quest.accept, { { id = "close", label = "On it", enabled = true } })
end
function ACTIONS.about(player: Player, resident, questId: string)
local quest = Town.findQuest(questId)
if not quest then
return
end
local have = Profile.progressOf(player, quest)
say(player, resident, `{quest.progress} ({have}/{quest.objective.count})`, {
{ id = "talk", label = "Understood", enabled = true },
{ id = "close", label = "Leave", enabled = true },
})
end
function ACTIONS.turnin(player: Player, resident, questId: string)
local quest = Town.findQuest(questId)
if not quest then
return
end
local reward = Profile.turnIn(player, quest)
if not reward then
return
end
Audio.playAt("levelUp", resident.position)
Vfx.sparks(resident.position + V(0, 6, 0), 26, Theme.Color.Unique)
if reward.item then
Network.Loot:FireClient(player, reward.item)
end
if reward.xp then
Network.EnemyDefeated:FireClient(player, "quest", reward.xp)
end
say(player, resident, quest.complete, {
{ id = "close", label = `Take {reward.gold} gold`, enabled = true, highlight = true },
})
end
--[[
The crafting bench.
Sends the whole recipe list every time, with each entry already resolved
against what the player is carrying — `have` per ingredient, and a single
`ready` flag. Working that out on the server rather than the client means
the panel can never offer a craft the server will then refuse, which is the
specific failure that makes a crafting UI feel broken.
]]
local function openBench(player: Player, resident)
local data = Profile.get(player)
if not data then
return
end
local list = {}
for _, recipe in Crafting.Recipes do
local unlocked = not recipe.requires or data.quests[recipe.requires] == "done"
local needs, ready = {}, unlocked
for _, ingredient in recipe.needs do
local have = data.materials[ingredient.id] or 0
local material = Town.Materials[ingredient.id]
table.insert(needs, {
id = ingredient.id,
name = material and material.name or ingredient.id,
need = ingredient.count,
have = have,
})
if have < ingredient.count then
ready = false
end
end
if data.gold < recipe.fee then
ready = false
end
table.insert(list, {
id = recipe.id,
name = recipe.name,
rarity = recipe.rarity,
slot = recipe.slot,
description = recipe.description,
stats = recipe.stats,
fee = recipe.fee,
needs = needs,
unlocked = unlocked,
lockedBy = recipe.lockedBy,
ready = ready,
})
end
Network.Craft:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
greeting = "Put it on the bench. I'll tell you what it wants.",
recipes = list,
gold = data.gold,
})
end
function ACTIONS.craft(player: Player, resident)
if resident.state ~= "work" then
say(player, resident, "Bench is cold. Come back when I'm at it.")
return
end
openBench(player, resident)
end
--[[
Makes one item.
Charges the fee first and refunds it if any material turns out to be
missing. Taking the gold and then discovering the bag is short is how a
player loses a purchase to a race with their own inventory.
]]
function ACTIONS.make(player: Player, resident, recipeId: string)
local recipe = Crafting.find(recipeId)
local data = Profile.get(player)
if not (recipe and data and resident.state == "work") then
return
end
if recipe.requires and data.quests[recipe.requires] ~= "done" then
say(player, resident, recipe.lockedBy or "Not yet.")
return
end
for _, ingredient in recipe.needs do
if (data.materials[ingredient.id] or 0) < ingredient.count then
say(player, resident, "You're short. Look at the list, not at me.")
return
end
end
if not Profile.spendGold(player, recipe.fee) then
say(player, resident, `The bench costs {recipe.fee}. I don't set the rate.`)
return
end
for _, ingredient in recipe.needs do
if not Profile.takeMaterial(player, ingredient.id, ingredient.count) then
-- Should be unreachable given the check above; refund rather than
-- silently eat the fee if it ever isn't.
Profile.addGold(player, recipe.fee)
return
end
end
Profile.addItem(player, recipe.id, 1)
Network.Loot:FireClient(player, {
id = recipe.id,
name = recipe.name,
rarity = recipe.rarity,
slot = recipe.slot,
description = recipe.description,
stats = recipe.stats,
quantity = 1,
})
Audio.playAt(if recipe.rarity == "Unique" then "unique" else "levelUp", resident.position)
Vfx.sparks(resident.position + V(0, 5, 0), 22, (Theme.Rarity[recipe.rarity] or Theme.Rarity.Common).Color)
openBench(player, resident)
end
--- The arena gate. The Colosseum script owns the run; this only points at it.
function ACTIONS.arena(player: Player, resident)
Network.Dialogue:FireClient(player, {
npcId = resident.npc.id,
name = resident.npc.name,
title = resident.npc.title,
text = "Five waves, one floor. Walk west down the causeway and step onto the sand — "
.. "it starts when you're on it. Nothing stops you leaving, but leaving ends the run.",
options = { { id = "close", label = "Understood", enabled = true } },
})
end
function ACTIONS.close(player: Player)
Network.Dialogue:FireClient(player, nil)
Network.Shop:FireClient(player, nil)
Network.Craft:FireClient(player, nil)
end
Network.Interact.OnServerEvent:Connect(function(player, npcId, action, arg)
if typeof(action) ~= "string" then
return
end
if action == "close" then
ACTIONS.close(player)
return
end
local resident = residents[npcId]
if not resident then
return
end
-- Range is re-checked on every action, not just the first: a shop panel
-- left open while you walk away must not still be able to buy.
if not inRange(player, resident) then
ACTIONS.close(player)
return
end
-- "offer:quest_id" style actions carry their argument in the id.
local verb, payload = string.match(action, "^(%w+):(.+)$")
local handler = ACTIONS[verb or action]
if handler then
handler(player, resident, payload or arg)
end
end)
--------------------------------------------------------------------------------
local function build()
local existing = Workspace:FindFirstChild(FOLDER)
if existing then
existing:Destroy()
end
table.clear(lanterns)
table.clear(residents)
folder = Create("Folder", { Name = FOLDER, Parent = Workspace })
buildWalls()
buildStreet()
buildPlaza()
for _, spec in Town.Buildings do
local model = buildBuilding(spec)
dressExterior(spec, model)
dressInterior(spec, model)
end
buildTower()
buildHouses()
buildLanterns()
dressStreets()
spawnResidents()
print(
`[Town] Firstia built: {#Town.Buildings} buildings, {#Town.Npcs} residents, `
.. `{#lanterns} lights, {#fires} fires, {#folder:GetDescendants()} parts`
)
end
build()
RunService.Heartbeat:Connect(function(dt)
driveResidents(dt)
driveLights(dt)
end)
-- Closing whatever was open when someone leaves keeps no stale panel state.
Players.PlayerRemoving:Connect(function(player)
ACTIONS.close(player)
end)
]]>
-
World
0
0.6 then
continue
end
local px = side * (World.RoadHalfWidth + rng:NextNumber(0.5, 3.5))
local pz = z + rng:NextNumber(-6, 6)
local origin = CFrame.new(px, World.groundHeight(px, pz) - 0.3, pz)
* CFrame.Angles(0, rng:NextNumber(0, math.pi * 2), 0)
local model = if rng:NextNumber() < 0.3
then Foliage.rock(origin, rng, rng:NextNumber(0.3, 0.6))
else Foliage.grass(origin, rng)
model.Parent = folder
end
end
end
local function placeSpawn(folder: Folder)
-- Retire any spawn from the template place, or players keep appearing in
-- whatever grey void the baseplate left behind.
for _, descendant in Workspace:GetDescendants() do
if descendant:IsA("SpawnLocation") and not descendant:IsDescendantOf(folder) then
descendant:Destroy()
end
end
local y = World.groundHeight(World.Spawn.X, World.Spawn.Z)
Create("SpawnLocation", {
Name = "ForestSpawn",
Anchored = true,
Size = Vector3.new(16, 1, 16),
-- Facing north, up the road toward Firstia.
CFrame = CFrame.new(World.Spawn.X, y + 0.5, World.Spawn.Z) * CFrame.Angles(0, math.pi, 0),
Color = Color3.fromRGB(96, 92, 82),
Material = Enum.Material.Slate,
TopSurface = Enum.SurfaceType.Smooth,
Duration = 0,
Parent = folder,
})
end
local function build()
local started = os.clock()
clearPrevious()
local folder = Create("Folder", { Name = FOLDER_NAME, Parent = Workspace })
fillTerrain()
local placed = scatter(folder)
dressRoad(folder)
placeSpawn(folder)
local town = Firstia(CFrame.new(World.FirstiaPosition) * CFrame.Angles(0, math.pi, 0))
town.Parent = folder
print(
string.format(
"[World] Rampant Forest built in %.1fs — %d props, road north to Firstia.",
os.clock() - started,
placed
)
)
end
build()
]]>
-
StarterPlayer
-
StarterPlayerScripts
-
Client
-
Admin
(),
}
local function register(spec: CommandSpec)
local command = Instance.new("TextChatCommand")
command.Name = spec.alias
command.PrimaryAlias = `/{spec.alias}`
if spec.secondary then
command.SecondaryAlias = `/{spec.secondary}`
end
command.AutocompleteVisible = true
command.Parent = TextChatService
command.Triggered:Connect(function(_source, text)
local ok, err = pcall(spec.run, parseArgs(text))
if not ok then
systemMessage(`/{spec.alias} failed: {err}`)
end
end)
table.insert(registered, { alias = spec.alias, args = spec.args, help = spec.help })
end
--------------------------------------------------------------------------------
-- Shared actions
--------------------------------------------------------------------------------
local bossIndex = 0
local function damagePlayer(amount: number)
if UIState.get("dead") then
return
end
local health = math.max(UIState.get("health") - amount, 0)
UIState.set("health", health)
UI.DamageNumbers.show(amount, "taken")
if health <= 0 then
UIState.patch({ dead = true, boss = nil })
end
end
local function damageBoss(amount: number, crit: boolean)
local boss = UIState.get("boss")
if not boss then
return
end
boss.health = math.max(boss.health - amount, 0)
if boss.maxPhase and boss.maxPhase > 1 then
boss.phase = math.max(math.ceil(boss.health / boss.maxHealth * boss.maxPhase), 1)
end
UIState.set("boss", boss)
UI.DamageNumbers.show(amount, if crit then "crit" else "normal")
if boss.health <= 0 then
UI.Toast.push({ title = `{boss.name} defeated`, subtitle = "Encounter cleared", kind = "quest" })
task.delay(1.2, function()
if UIState.get("boss") == boss then
UIState.set("boss", nil)
end
end)
end
end
local function engageBoss(which: number?)
local existing = UIState.get("boss")
-- No argument and a boss already up: treat it as "hit it".
if not which and existing and existing.health > 0 then
local crit = math.random() < 0.25
damageBoss(math.random(2000, 6000) * (if crit then 3 else 1), crit)
return
end
if which then
bossIndex = math.clamp(which, 1, #BOSSES)
else
bossIndex = bossIndex % #BOSSES + 1
end
local template = BOSSES[bossIndex]
UIState.set("boss", {
name = template.name,
title = template.title,
health = template.maxHealth,
maxHealth = template.maxHealth,
phase = template.maxPhase,
maxPhase = template.maxPhase,
unique = template.unique,
})
systemMessage(`Engaged {template.name}. /boss again to damage it.`)
end
--------------------------------------------------------------------------------
-- Commands
--------------------------------------------------------------------------------
local function registerAll()
register({
alias = "damage",
secondary = "dmg",
args = "[amount]",
help = "Take damage. Random 40-120 with no amount.",
run = function(args)
damagePlayer(tonumber(args[1]) or math.random(40, 120))
end,
})
register({
alias = "heal",
args = "[amount]",
help = "Heal. Restores everything with no amount.",
run = function(args)
local maxHealth = UIState.get("maxHealth")
local amount = tonumber(args[1])
local health = if amount then math.min(UIState.get("health") + amount, maxHealth) else maxHealth
local gained = health - UIState.get("health")
UIState.set("health", health)
if gained > 0 then
UI.DamageNumbers.show(gained, "heal")
end
end,
})
register({
alias = "boss",
args = "[1-3]",
help = "Engage a boss, or damage the current one.",
run = function(args)
engageBoss(tonumber(args[1]))
end,
})
register({
alias = "scenario",
args = "[name]",
help = "Play the Unique Scenario banner.",
run = function(args)
local name = if #args > 0 then table.concat(args, " ") else "Vorpal Bunny"
UI.ScenarioBanner.play({
kicker = "Unique Scenario",
name = name,
note = "First clear across all servers",
})
end,
})
register({
alias = "toast",
help = "Show a random notification.",
run = function()
local samples = {
{ title = "Vorpal Fang", subtitle = "Unique weapon", kind = "loot" },
{ title = "Level up", subtitle = "Reached level 12", kind = "levelup" },
{ title = "Curse applied", subtitle = "Nightslayer's Beak", kind = "curse" },
{ title = "Party member down", subtitle = "Pencilgon", kind = "warning" },
}
UI.Toast.push(samples[math.random(#samples)])
end,
})
register({
alias = "status",
args = "[buff|debuff|curse]",
help = "Apply a timed status effect.",
run = function(args)
local kinds = { "buff", "debuff", "curse" }
local labels = { "Haste", "Bleed", "Cursed Mark", "Fortified", "Poison" }
local kind = args[1]
if not table.find(kinds, kind) then
kind = kinds[math.random(#kinds)]
end
local statuses = UIState.get("statuses")
table.insert(statuses, {
id = `status_{os.clock()}`,
label = labels[math.random(#labels)],
kind = kind,
expiresAt = os.clock() + math.random(5, 14),
})
UIState.set("statuses", statuses)
end,
})
register({
alias = "level",
args = "[amount]",
help = "Gain levels, with the stat growth and skill points that follow.",
run = function(args)
for _ = 1, math.clamp(tonumber(args[1]) or 1, 1, 100) do
Leveling.levelUp()
end
end,
})
register({
alias = "xp",
args = "[amount]",
help = "Grant experience, rolling levels over as it goes.",
run = function(args)
Leveling.addExperience(math.max(tonumber(args[1]) or 50, 1))
end,
})
register({
alias = "demo",
help = "Fill every menu with sample progression, for UI work.",
run = function()
UIState.patch({
inventory = DEMO_ITEMS,
equipment = { Head = "bird_helm", Weapon = "vorpal_fang", Body = "traveler_coat" },
selectedItem = "bird_helm",
skillPoints = 5,
unlockedSkills = { "step", "read", "secondwind" },
loadout = { "step" },
earnedTitles = { "kusoge_hunter", "bird_brain" },
equippedTitle = "kusoge_hunter",
parryRank = 2,
scenarioStates = {
vorpal_bunny = "cleared",
lycagon = "active",
rustclad = "taken",
},
})
for _ = 1, 10 do
Leveling.levelUp()
end
systemMessage("Demo state applied.")
end,
})
register({
alias = "setscenario",
args = " ",
help = "Force a scenario's state.",
run = function(args)
local id, newState = args[1], args[2]
if not (id and newState) then
systemMessage("Usage: /setscenario ")
return
end
local states = UIState.get("scenarioStates") or {}
states[id] = newState
UIState.set("scenarioStates", states)
systemMessage(`{id} -> {newState}`)
end,
})
register({
alias = "kill",
help = "Die, and open the death screen.",
run = function()
UIState.patch({ health = 0, dead = true, boss = nil })
end,
})
register({
alias = "revive",
help = "Clear the death state and restore vitals.",
run = function()
UIState.patch({
dead = false,
health = UIState.get("maxHealth"),
stamina = UIState.get("maxStamina"),
})
end,
})
register({
alias = "dive",
help = "Replay the dive sequence from the top.",
run = function()
UI.Flow.replayBoot()
end,
})
register({
alias = "skip",
help = "Skip the front-end straight into gameplay.",
run = function()
UI.Flow.skipToPlaying({ name = "Sunraku", origin = "traveler", race = "human", style = "unarmed" })
end,
})
register({
alias = "give",
help = "Reseed the demo inventory and equipment.",
run = function()
UIState.patch({
inventory = DEMO_ITEMS,
equipment = { Head = "bird_helm", Weapon = "vorpal_fang", Body = "traveler_coat" },
selectedItem = "bird_helm",
})
systemMessage(`Gave {#DEMO_ITEMS} demo items.`)
end,
})
register({
alias = "points",
args = "[amount]",
help = "Grant skill points. Three with no amount.",
run = function(args)
local gain = math.max(tonumber(args[1]) or 3, 1)
UIState.set("skillPoints", (UIState.get("skillPoints") or 0) + gain)
systemMessage(`Skill points: {UIState.get("skillPoints")}`)
end,
})
register({
alias = "gallery",
help = "Teleport to the creature lineup.",
run = function()
local character = Players.LocalPlayer.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not root then
systemMessage("No character to move.")
return
end
-- Positioned looking at the line rather than dropped beside it.
root.CFrame = CFrame.new(World.GalleryView, World.GalleryCenter + Vector3.new(0, 5, 0))
end,
})
register({
alias = "time",
args = "[0-24]",
help = "Set the time of day. Reports it with no argument.",
run = function(args)
local hour = tonumber(args[1])
if not hour then
systemMessage(`ClockTime is {string.format("%.1f", Lighting.ClockTime)}`)
return
end
Lighting.ClockTime = math.clamp(hour, 0, 24)
systemMessage(`ClockTime {string.format("%.1f", Lighting.ClockTime)}`)
end,
})
register({
alias = "bright",
args = "[value]",
help = "Set Lighting.Brightness. Reports it with no argument.",
run = function(args)
local value = tonumber(args[1])
if not value then
systemMessage(
`Brightness {string.format("%.2f", Lighting.Brightness)}, `
.. `exposure {string.format("%.2f", Lighting.ExposureCompensation)}`
)
return
end
Lighting.Brightness = math.clamp(value, 0, 10)
systemMessage(`Brightness {string.format("%.2f", Lighting.Brightness)}`)
end,
})
register({
alias = "exposure",
args = "[value]",
help = "Set exposure compensation. Negative is darker.",
run = function(args)
local value = tonumber(args[1])
if not value then
systemMessage(`Exposure {string.format("%.2f", Lighting.ExposureCompensation)}`)
return
end
Lighting.ExposureCompensation = math.clamp(value, -5, 5)
systemMessage(`Exposure {string.format("%.2f", Lighting.ExposureCompensation)}`)
end,
})
register({
alias = "parry",
args = "[0-3]",
help = "Set your parry rank. 0 locks it, 3 is max.",
run = function(args)
local Parry = require(game:GetService("ReplicatedStorage").Shared.Config.Parry)
local rank = math.clamp(math.floor(tonumber(args[1]) or Parry.maxRank()), 0, Parry.maxRank())
UIState.set("parryRank", rank)
local tier = Parry.forRank(rank)
systemMessage(if tier then `Parry rank {rank} — {tier.summary}` else "Parry locked.")
end,
})
register({
alias = "helper",
args = "[off|adaptive|always]",
help = "Set the parry helper mode.",
run = function(args)
local mode = string.lower(args[1] or "")
if mode ~= "off" and mode ~= "adaptive" and mode ~= "always" then
systemMessage(`Parry helper is "{UIState.get("parryHelper")}". Usage: /helper off|adaptive|always`)
return
end
UIState.set("parryHelper", mode)
systemMessage(`Parry helper: {mode}`)
end,
})
register({
alias = "unlockall",
help = "Unlock every skill for the current style.",
run = function()
local character = UIState.get("character")
local unlocked = UIState.get("unlockedSkills") or {}
for _, skill in Skills.forStyle(character and character.style) do
if not table.find(unlocked, skill.id) then
table.insert(unlocked, skill.id)
end
end
UIState.set("unlockedSkills", unlocked)
systemMessage(`Unlocked {#unlocked} skills.`)
end,
})
register({
alias = "cooldowns",
secondary = "cd",
help = "Clear all ability cooldowns.",
run = function()
UIState.set("cooldowns", {})
systemMessage("Cooldowns cleared.")
end,
})
register({
alias = "menu",
args = "[tab]",
help = "Open the character menu, optionally on a named tab.",
run = function(args)
local tabs = { "status", "inventory", "skills", "scenarios", "titles" }
local tab = string.lower(args[1] or "")
if table.find(tabs, tab) then
UIState.set("menuTab", tab)
end
UIState.set("menuOpen", "menu")
end,
})
register({
alias = "help",
help = "List every admin command.",
run = function()
systemMessage("— Admin commands —")
for _, entry in registered do
local usage = if entry.args then `/{entry.alias} {entry.args}` else `/{entry.alias}`
systemMessage(`{usage} · {entry.help}`)
end
end,
})
end
--------------------------------------------------------------------------------
local function authorised(): boolean
if RunService:IsStudio() then
return true
end
return table.find(ALLOWED_USER_IDS, Players.LocalPlayer.UserId) ~= nil
end
function Admin.start()
-- Nothing is seeded. A character starts at level 1 with an empty bag, no
-- unlocks and no titles; /demo exists for when you want the menus full.
if not authorised() then
return
end
if TextChatService.ChatVersion ~= Enum.ChatVersion.TextChatService then
warn("[Admin] Commands need TextChatService; legacy chat is enabled, so they are unavailable.")
return
end
registerAll()
end
return Admin
]]>
-
Controllers
-
Abilities
your level is too low for this slot
empty -> no skill assigned
cooldown -> still recharging
stamina -> can't afford it
Effects live in EFFECTS, keyed by skill id, with a generic fallback. Real
combat lands later; the framework and its costs are what matter now.
]]
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Bindings = require(ReplicatedStorage.Shared.Config.Bindings)
local Encounters = require(ReplicatedStorage.Shared.Config.Encounters)
local Network = require(ReplicatedStorage.Shared.Network)
local Skills = require(ReplicatedStorage.Shared.Config.Skills)
local Events = require(script.Parent.Parent.UI.Core.Events)
local Loadout = require(script.Parent.Parent.UI.Core.Loadout)
local UI = require(script.Parent.Parent.UI)
local UIState = UI.State
local DASH_SPEED = 62
local Abilities = {}
-- Signals live on the Events bus so the HUD can listen without requiring this
-- module back. See Events.luau.
Abilities.Cast = Events.AbilityCast
Abilities.Failed = Events.AbilityFailed
--------------------------------------------------------------------------------
-- Effects
--------------------------------------------------------------------------------
local function dash()
local character = Players.LocalPlayer.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
local root = character and character:FindFirstChild("HumanoidRootPart")
if not (humanoid and root) then
return
end
local direction = humanoid.MoveDirection
if direction.Magnitude < 0.1 then
direction = root.CFrame.LookVector
end
-- Flatten so a dash never launches you off a slope, and guard the Unit
-- call -- a zero vector normalises to NaN and would fling the character.
direction = Vector3.new(direction.X, 0, direction.Z)
if direction.Magnitude < 0.01 then
return
end
root.AssemblyLinearVelocity = direction.Unit * DASH_SPEED + Vector3.new(0, root.AssemblyLinearVelocity.Y, 0)
end
local EFFECTS = {
step = function()
dash()
-- The i-frames are the actual skill; the dash is just how you leave.
-- Told to the server because only the server decides whether a lunge
-- connected.
Network.Invulnerable:FireServer(Encounters.DodgeInvulnerability)
end,
secondwind = function()
local max = UIState.get("maxStamina")
UIState.set("stamina", math.min(UIState.get("stamina") + max * 0.3, max))
UI.DamageNumbers.show(math.floor(max * 0.3), "heal")
end,
}
--- Everything without a bespoke effect still reads as *something happening*.
local function genericEffect(skill)
UI.Toast.push({ title = skill.name, subtitle = "Used", kind = "system", duration = 1.6 })
end
--------------------------------------------------------------------------------
Abilities.assign = Loadout.assign
Abilities.remainingCooldown = Loadout.remainingCooldown
function Abilities.cast(slotIndex: number)
if UIState.get("phase") ~= "playing" or UIState.get("dead") then
return
end
if not Loadout.isSlotUnlocked(slotIndex) then
Abilities.Failed:Fire(slotIndex, "locked")
return
end
local skill = Skills.find(Loadout.get(slotIndex))
if not skill then
Abilities.Failed:Fire(slotIndex, "empty")
return
end
if Loadout.remainingCooldown(skill.id) > 0 then
Abilities.Failed:Fire(slotIndex, "cooldown")
return
end
local cost = skill.staminaCost or 0
if UIState.get("stamina") < cost then
Abilities.Failed:Fire(slotIndex, "stamina")
return
end
if cost > 0 then
UIState.set("stamina", UIState.get("stamina") - cost)
end
if skill.cooldown and skill.cooldown > 0 then
local cooldowns = UIState.get("cooldowns") or {}
cooldowns[skill.id] = os.clock() + skill.cooldown
UIState.set("cooldowns", cooldowns)
end
local effect = EFFECTS[skill.id]
if effect then
effect(skill)
else
genericEffect(skill)
end
Abilities.Cast:Fire(slotIndex, skill)
end
function Abilities.start()
-- Slot order comes from Skills, the action names from Bindings, so a slot
-- gains its gamepad button by existing rather than by being listed twice.
local actions = {}
for action in Bindings.SkillSlots do
table.insert(actions, action)
end
UserInputService.InputBegan:Connect(function(input, processed)
if processed then
return
end
local action = Bindings.resolve(input, actions)
if action then
Abilities.cast(Bindings.SkillSlots[action])
end
end)
-- Losing a level must not leave a skill sitting in a slot you can no
-- longer use.
UIState.observe("level", function()
Loadout.prune()
end)
end
return Abilities
]]>
-
Acoustics
zone.below then
return 0
end
local flat = Vector3.new(at.X - zone.center.X, 0, at.Z - zone.center.Z)
local outside
if zone.radius then
outside = flat.Magnitude - zone.radius
else
-- Box distance: how far past the nearest face, on whichever axis is worst.
outside = math.max(math.abs(flat.X) - zone.half.X, math.abs(flat.Z) - zone.half.Z)
end
return math.clamp(1 - outside / Mix.SpaceFalloff, 0, 1)
end
local function spaceAt(at: Vector3): string
local best, bestStrength = Mix.DefaultSpace, 0
for _, zone in ZONES do
local strength = strengthOf(zone, at)
if strength > bestStrength then
best, bestStrength = zone.space, strength
end
end
return best
end
--------------------------------------------------------------------------------
local effect: ReverbSoundEffect? = nil
local current = Mix.DefaultSpace
local tween: Tween? = nil
local function applySpace(id: string)
local space = Mix.Spaces[id]
if not (effect and space) then
return
end
if tween then
tween:Cancel()
end
tween = TweenService:Create(effect, TweenInfo.new(Mix.SpaceBlend), {
DecayTime = space.decay,
Density = space.density / 100,
Diffusion = space.diffusion / 100,
WetLevel = space.wet,
DryLevel = space.dry,
})
tween:Play()
end
function Acoustics.start()
task.spawn(function()
-- The bus tree is built by the server, so it arrives a moment after the
-- client does. Poll rather than block: reverb turning up late is
-- unnoticeable, a controller that never starts is not.
local group
for _ = 1, 100 do
group = Audio.group("Sfx")
if group then
break
end
task.wait(0.1)
end
if not group then
warn("[Acoustics] effects bus never arrived; running dry")
return
end
local space = Mix.Spaces[Mix.DefaultSpace]
effect = Instance.new("ReverbSoundEffect")
effect.Name = "Space"
effect.DecayTime = space.decay
effect.Density = space.density / 100
effect.Diffusion = space.diffusion / 100
effect.WetLevel = space.wet
effect.DryLevel = space.dry
effect.Parent = group
end)
-- Quarter-second cadence. The blend is nearly a second long, so sampling
-- any faster costs frames to decide something the ear cannot resolve.
task.spawn(function()
while true do
task.wait(0.25)
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if root and effect then
local found = spaceAt(root.Position)
if found ~= current then
current = found
applySpace(found)
end
end
end
end)
end
--- Which space the player is currently in. Exposed for the admin readout and
--- for anything that wants to react to being indoors.
function Acoustics.space(): string
return current
end
return Acoustics
]]>
-
Ambience
= MAX_SWAYING then
break
end
if not model:IsA("Model") or not model:GetAttribute("Foliage") then
continue
end
local pivot = model:GetPivot().Position
local distance = (Vector3.new(pivot.X, 0, pivot.Z) - Vector3.new(around.X, 0, around.Z)).Magnitude
if distance > SWAY_RANGE then
continue
end
-- Nearer trees sway more visibly; far ones would just shimmer.
local falloff = 1 - (distance / SWAY_RANGE) ^ 2
for _, part in model:GetChildren() do
if not part:IsA("BasePart") then
continue
end
local name = part.Name
if not (string.find(name, "Canopy") or string.find(name, "Tier") or string.find(name, "Clump")) then
continue
end
table.insert(swaying, {
part = part,
rest = part.CFrame,
-- Per-part phase, so a tree ripples rather than moving as a slab.
phase = (pivot.X + pivot.Z + part.Position.Y) * 0.35,
amount = falloff * (0.6 + math.random() * 0.7),
})
if #swaying >= MAX_SWAYING then
break
end
end
end
end
--------------------------------------------------------------------------------
local function step(dt: number)
clock += dt
local position = characterPosition()
if not position then
return
end
------------------------------------------------------------------------
-- Wind. Direction and strength both wander; gusts arrive on their own.
------------------------------------------------------------------------
windAngle += dt * 0.05
windStrength = 0.45 + math.sin(clock * 0.07) * 0.3
if os.clock() > gustUntil and math.random() < dt * 0.06 then
gustUntil = os.clock() + 1.6 + math.random() * 2.2
gustStrength = 1.2 + math.random() * 1.4
Audio.playAt("windRush", position)
-- A gust shakes leaves loose ahead of it, which is what actually sells
-- it — you see the wind arrive before you feel it.
Vfx.leaves(position + Vector3.new(math.random(-40, 40), 0, math.random(-40, 40)), 8)
end
local gust = if os.clock() < gustUntil then gustStrength else 0
local strength = windStrength + gust
local windX = math.cos(windAngle)
local windZ = math.sin(windAngle)
------------------------------------------------------------------------
-- Canopy sway
------------------------------------------------------------------------
rebuildTimer -= dt
if rebuildTimer <= 0 then
rebuildTimer = REBUILD_INTERVAL
rebuild(position)
end
for _, entry in swaying do
if not entry.part.Parent then
continue
end
local wave = math.sin(clock * 1.35 + entry.phase)
local lift = math.sin(clock * 0.9 + entry.phase * 1.4) * 0.25
local push = wave * entry.amount * strength
entry.part.CFrame = entry.rest
* CFrame.new(windX * push * 0.5, lift * entry.amount, windZ * push * 0.5)
* CFrame.Angles(math.rad(windZ * push * 2.2), 0, math.rad(-windX * push * 2.2))
end
------------------------------------------------------------------------
-- Loose leaves, more often in wind
------------------------------------------------------------------------
leafTimer -= dt * (0.6 + strength)
if leafTimer <= 0 then
leafTimer = 2.5 + math.random() * 3.5
Vfx.leaves(position + Vector3.new(math.random(-45, 45), 0, math.random(-45, 45)), 3)
end
end
--------------------------------------------------------------------------------
-- Air
--------------------------------------------------------------------------------
--[[
Motes by day, fireflies by night.
One emitter, parented to a part that rides along with the player, rather
than thousands of particles scattered across the map. The player only ever
sees the volume they are standing in, so simulating anything further out is
paying for atmosphere nobody can look at.
This is the cheapest large upgrade available to a scene built from flat
primitives: particles in the air give the light something to catch, and a
still frame stops reading as a diagram of a place and starts reading as
being in one.
]]
local airPart: BasePart
local airEmitter: ParticleEmitter
local isNight = false
local function buildAir()
airPart = Instance.new("Part")
airPart.Name = "Air"
-- A wide, shallow box: particles spawn all around the player and drift, so
-- they never appear to be emitted *by* them.
airPart.Size = Vector3.new(90, 26, 90)
airPart.Transparency = 1
airPart.Anchored = true
airPart.CanCollide = false
airPart.CanQuery = false
airPart.CanTouch = false
airPart.Parent = Workspace
airEmitter = Instance.new("ParticleEmitter")
airEmitter.Texture = "rbxasset://textures/particles/sparkles_main.dds"
airEmitter.Rate = 26
airEmitter.Lifetime = NumberRange.new(4, 8)
airEmitter.Speed = NumberRange.new(0.4, 1.6)
airEmitter.SpreadAngle = Vector2.new(180, 180)
airEmitter.Drag = 1.4
-- Emitted through a wide box around the player, so they drift past rather
-- than streaming out of a point at their feet.
airEmitter.Shape = Enum.ParticleEmitterShape.Box
airEmitter.ShapeStyle = Enum.ParticleEmitterShapeStyle.Volume
airEmitter.Size = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0),
NumberSequenceKeypoint.new(0.25, 0.3),
NumberSequenceKeypoint.new(0.75, 0.3),
NumberSequenceKeypoint.new(1, 0),
})
airEmitter.Parent = airPart
end
--- Motes are pale, slow and nearly invisible; fireflies are warm, bright and
--- few. Swapping the emitter's look rather than its existence keeps one object
--- doing both jobs.
local function setAirMood(night: boolean)
if night then
airEmitter.Rate = 10
airEmitter.Color = ColorSequence.new(Color3.fromRGB(196, 255, 140), Color3.fromRGB(255, 226, 128))
airEmitter.LightEmission = 1
airEmitter.LightInfluence = 0
airEmitter.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.2, 0.1),
NumberSequenceKeypoint.new(0.5, 0.55),
NumberSequenceKeypoint.new(0.8, 0.1),
NumberSequenceKeypoint.new(1, 1),
})
else
airEmitter.Rate = 26
airEmitter.Color = ColorSequence.new(Color3.fromRGB(255, 248, 226))
airEmitter.LightEmission = 0.35
airEmitter.LightInfluence = 1
airEmitter.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.3, 0.82),
NumberSequenceKeypoint.new(0.7, 0.82),
NumberSequenceKeypoint.new(1, 1),
})
end
end
local function stepAir()
local at = characterPosition()
if not at then
airEmitter.Enabled = false
return
end
airEmitter.Enabled = true
airPart.CFrame = CFrame.new(at + Vector3.new(0, 6, 0))
end
--------------------------------------------------------------------------------
function Ambience.start()
buildAir()
setAirMood(false)
Network.TimeOfDay.OnClientEvent:Connect(function(_hour, night)
if night ~= isNight then
isNight = night
setAirMood(night)
end
end)
RunService.Heartbeat:Connect(function(dt)
local ok, err = pcall(step, dt)
if not ok then
warn(`[Ambience] {err}`)
end
stepAir()
end)
end
return Ambience
]]>
-
BossIntro
-
Combat
ATTACK.comboReset then
comboIndex = 0
end
comboIndex = comboIndex % #COMBO + 1
local step = COMBO[comboIndex]
local stamina = UIState.get("stamina")
if stamina < step.stamina then
comboIndex = math.max(comboIndex - 1, 0)
return
end
UIState.set("stamina", stamina - step.stamina)
swing = { step = step, index = comboIndex, startedAt = now }
Network.Attack:FireServer(comboIndex)
end
local function requestSwing()
if not canAct() or blocking then
return
end
if not swing then
beginSwing()
return
end
-- Mid-swing: remember it. Fired the instant recovery opens.
bufferedAt = os.clock()
end
--------------------------------------------------------------------------------
-- Parry
--------------------------------------------------------------------------------
--[[
Pressing F asks the server to open a window. It does not assert a parry.
The visuals fire immediately anyway — a defensive input that waits a round
trip before showing anything feels broken even when it works. The server's
verdict arrives a moment later and decides what actually happened; if it
refuses (cooldown, not unlocked) the predicted flash is simply replaced by
the refusal cue.
]]
local function requestParry()
if not canAct() then
return
end
-- Never fail silently. Pressing a key and getting nothing at all is
-- indistinguishable from a broken game, and this was exactly that: anyone
-- who hadn't finished the tutorial pressed F forever with no response.
if (UIState.get("parryRank") or 0) <= 0 then
UI.Toast.push({
title = "Parry not unlocked",
subtitle = "Menu (B) → Skills → Core",
kind = "warning",
duration = 3.5,
})
ScreenFx.flash(Color3.fromRGB(120, 130, 150), 0.14)
return
end
if os.clock() < (UIState.get("parryReadyAt") or 0) then
ScreenFx.flash(Color3.fromRGB(120, 130, 150), 0.12)
return
end
-- Predicted: guard snaps up now, server confirms in a moment.
parryPredictedUntil = os.clock() + 0.2
-- The rank rides along, because the periodic vitals report can be stale by
-- up to 250ms and the server would otherwise refuse a parry you own.
Network.Parry:FireServer(UIState.get("parryRank") or 0)
end
local function onParryResult(accepted: boolean, reason: string, cooldown: number, window: number)
local now = os.clock()
if accepted then
UIState.patch({
parryReadyAt = now + cooldown,
parryWindowUntil = now + window,
})
return
end
-- Refused. Drop the prediction so the arm doesn't hold a pose the server
-- never granted, and say why.
parryPredictedUntil = 0
if reason == "locked" then
UI.Toast.push({
title = "Parry not unlocked",
subtitle = "Menu (B) → Skills → Core",
kind = "warning",
duration = 3.5,
})
elseif cooldown and cooldown > 0 then
UIState.set("parryReadyAt", now + cooldown)
end
end
--------------------------------------------------------------------------------
-- Guard
--------------------------------------------------------------------------------
--[[
Block is held on C, not the right mouse button.
Right mouse is Roblox's own camera control — holding it turns the camera,
and every player on the platform already knows that. Binding block to it
meant you could not look around while guarding, which is the one moment you
most need to. C is unbound, reachable with the left hand while WASD is held,
and does not fight anything the engine already owns.
The key itself lives in `Config/Bindings` along with its gamepad trigger.
]]
local function setBlocking(held: boolean)
if blocking == held then
return
end
if held and not canAct() then
return
end
blocking = held
UIState.set("blocking", held)
Network.Block:FireServer(held)
end
--------------------------------------------------------------------------------
-- Feel
--------------------------------------------------------------------------------
local function onImpact(kind: string, data)
if kind == "parry" then
Haptics.play("parry")
-- The fight's best moment gets the loudest response: freeze, white
-- pop, camera punch-in, hard shake, and the biggest hole the mix ever
-- opens. The assist drops out on the same frame, so time snapping back
-- is part of the reward.
Audio.duck("parry")
FocusFx.stop()
UIState.set("focusing", false)
freezeUntil = os.clock() + HITSTOP.parry
ScreenFx.shake(2.6)
ScreenFx.parry()
UI.Toast.push({ title = "Parry", subtitle = "Counter now", kind = "levelup", duration = 1.4 })
elseif kind == "heavy" then
Haptics.play("heavy")
Audio.duck("impact")
freezeUntil = os.clock() + HITSTOP.heavy
ScreenFx.shake(1.7)
ScreenFx.flash(Color3.fromRGB(255, 236, 190), 0.22)
elseif kind == "blocked" then
Haptics.play("hit")
freezeUntil = os.clock() + HITSTOP.light
ScreenFx.shake(1.2)
ScreenFx.flash(Color3.fromRGB(190, 220, 255), 0.3)
elseif kind == "hurt" then
Haptics.play("hurt")
ScreenFx.shake(3.4)
ScreenFx.hurt(0.7)
-- Knocked back by the hit. Applied client-side because the client owns
-- its own character's physics; the server only says which way.
if data and data.direction then
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if root then
root.AssemblyLinearVelocity = data.direction * (data.power or 40) + Vector3.new(0, 18, 0)
end
end
elseif kind == "guardBreak" then
Haptics.play("guardBreak")
-- Your guard failed rather than held, so it must not look like a block.
-- Red where a block is blue, a heavier freeze, and the same knockback a
-- clean hit gives, because that is what it was.
Audio.duck("impact")
freezeUntil = os.clock() + HITSTOP.heavy
ScreenFx.shake(4.0)
ScreenFx.flash(Color3.fromRGB(255, 90, 70), 0.45)
ScreenFx.hurt(0.9)
UIState.set("blocking", false)
blocking = false
if data and data.direction then
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if root then
root.AssemblyLinearVelocity = data.direction * (data.power or 60) + Vector3.new(0, 22, 0)
end
end
UI.Toast.push({ title = "Guard broken", subtitle = "Out of stamina", kind = "warning", duration = 1.6 })
elseif kind == "parryWhiff" then
-- Missed. No damage cue, but the lockout needs to be legible.
parryPredictedUntil = 0
ScreenFx.flash(Color3.fromRGB(90, 100, 120), 0.16)
elseif kind == "unparryable" then
-- Timed correctly, but this attack cannot be answered. Amber, not
-- white: you did the right thing to the wrong attack.
freezeUntil = os.clock() + HITSTOP.light
ScreenFx.shake(1.8)
ScreenFx.flash(Color3.fromRGB(255, 170, 80), 0.4)
UI.Toast.push({ title = "Unparryable", subtitle = "Move, do not guard", kind = "warning", duration = 1.6 })
elseif kind == "introStart" then
ScreenFx.push(-6)
else
freezeUntil = os.clock() + HITSTOP.light
ScreenFx.shake(0.8)
end
end
--- Per-link arm poses. Alternating directions so a chain reads as a sequence
--- of different swings rather than the same one four times.
local SWINGS = {
{ raise = Vector3.new(-70, 40, 0), strike = Vector3.new(-20, -55, 0) },
{ raise = Vector3.new(-70, -50, 0), strike = Vector3.new(-25, 50, 0) },
{ raise = Vector3.new(-110, 25, 0), strike = Vector3.new(-10, -40, 0) },
{ raise = Vector3.new(-160, 0, 0), strike = Vector3.new(10, 0, 0) },
}
local function poseArm()
if not (shoulder and shoulderRest) then
return
end
if not swing then
local parrying = os.clock() < parryPredictedUntil
local target = if parrying
then shoulderRest * CFrame.Angles(math.rad(-115), math.rad(-20), 0)
elseif blocking then shoulderRest * CFrame.Angles(math.rad(-75), math.rad(30), 0)
else shoulderRest
-- Snappier into a parry than a block: it is a flick, not a brace.
shoulder.C0 = shoulder.C0:Lerp(target, if parrying then 0.6 else 0.25)
return
end
local step = swing.step
local elapsed = os.clock() - swing.startedAt
local shape = SWINGS[swing.index] or SWINGS[1]
local angles
if elapsed < step.windup then
-- Wind back.
local t = elapsed / step.windup
angles = REST_ANGLES:Lerp(shape.raise, t * t)
elseif elapsed < step.windup + step.active then
-- Strike, fast and linear so it reads as a snap.
local t = (elapsed - step.windup) / step.active
angles = shape.raise:Lerp(shape.strike, t)
else
-- Settle back to rest.
local total = step.windup + step.active + step.recovery
local t = math.clamp((elapsed - step.windup - step.active) / step.recovery, 0, 1)
angles = shape.strike:Lerp(REST_ANGLES, t)
if elapsed >= total then
swing = nil
lastSwingEndedAt = os.clock()
end
end
shoulder.C0 = shoulderRest * CFrame.Angles(math.rad(angles.X), math.rad(angles.Y), math.rad(angles.Z))
end
--------------------------------------------------------------------------------
-- Server messages
--------------------------------------------------------------------------------
local function onPlayerDamaged(amount: number)
if UIState.get("dead") then
return
end
local health = math.max(UIState.get("health") - amount, 0)
UIState.set("health", health)
UI.DamageNumbers.show(amount, "taken")
if health <= 0 then
UIState.patch({ dead = true, boss = nil })
end
end
local function onGuardResult(staminaCost: number, parried: boolean)
if parried then
-- Higher parry ranks hand stamina back, arriving as a negative cost.
if staminaCost < 0 then
UIState.set("stamina", math.min(UIState.get("stamina") - staminaCost, UIState.get("maxStamina")))
end
parryPredictedUntil = 0
return
end
-- Blocking is a resource, not a wall: it holds until your stamina doesn't.
UIState.set("stamina", math.max(UIState.get("stamina") - staminaCost, 0))
end
local function onEncounterCleared(encounterId: string, rewardXp: number)
local scenario = Progression.findScenario(encounterId)
local states = UIState.get("scenarioStates") or {}
local alreadyCleared = states[encounterId] == "cleared"
states[encounterId] = "cleared"
UIState.set("scenarioStates", states)
if not alreadyCleared and scenario then
UI.ScenarioBanner.play({ kicker = scenario.kicker, name = scenario.name, note = "First clear" })
local titles = UIState.get("earnedTitles") or {}
if not table.find(titles, "first_blood") then
table.insert(titles, "first_blood")
UIState.set("earnedTitles", titles)
task.delay(4.5, function()
UI.Toast.push({ title = "Title earned", subtitle = "First Encounter", kind = "quest" })
end)
end
else
UI.Toast.push({ title = "Vorpal Bunny defeated", kind = "quest" })
end
task.delay(if alreadyCleared then 0.2 else 4.2, function()
Leveling.addExperience(rewardXp)
end)
end
--------------------------------------------------------------------------------
function Combat.start()
if player.Character then
task.spawn(bindArm, player.Character)
end
player.CharacterAdded:Connect(function(character)
task.wait(0.3)
bindArm(character)
end)
Network.BossState.OnClientEvent:Connect(function(payload)
UIState.set("boss", payload)
end)
Network.PlayerDamaged.OnClientEvent:Connect(onPlayerDamaged)
Network.BossDamaged.OnClientEvent:Connect(function(amount, kind, worldPosition)
UI.DamageNumbers.show(amount, kind, worldPosition)
end)
Network.Impact.OnClientEvent:Connect(onImpact)
Network.ParryResult.OnClientEvent:Connect(onParryResult)
--[[
An assisted attack is inbound. The ring closes exactly on impact, so
"press when the ring lands" trains the same motor skill as "press when
the sword lands" — just larger and slower. It never presses for you.
]]
Network.ParryPrompt.OnClientEvent:Connect(function(profile)
if not profile then
FocusFx.stop()
UIState.set("focusing", false)
return
end
FocusFx.show(profile.realLead, profile.visibility, profile.ring, profile.prompt)
UIState.set("focusing", true)
task.delay(profile.realLead + 0.05, function()
if not FocusFx.isActive() then
UIState.set("focusing", false)
end
end)
end)
-- Push the chosen setting up whenever it changes, and once on start.
UIState.observe("parryHelper", function(mode)
Network.AssistMode:FireServer(mode)
end)
-- And the rank, the moment it changes, rather than waiting for the next
-- vitals tick.
UIState.observe("parryRank", function()
local max = UIState.get("maxStamina")
if max and max > 0 then
Network.Vitals:FireServer(UIState.get("stamina") / max, UIState.get("parryRank"))
end
end)
-- The AI reads your stamina to decide when to press. Reported a few times
-- a second rather than every frame; it only drives flavour, not authority.
task.spawn(function()
while true do
task.wait(0.25)
local max = UIState.get("maxStamina")
if max and max > 0 then
Network.Vitals:FireServer(UIState.get("stamina") / max, UIState.get("parryRank"))
end
end
end)
Network.GuardResult.OnClientEvent:Connect(onGuardResult)
Network.EncounterCleared.OnClientEvent:Connect(onEncounterCleared)
--[[
Loot. Stacks with anything already carried, and always announces
itself — a drop the player doesn't notice may as well not have
happened, and "why did I walk over there" is the question every
open world has to keep answering.
]]
Network.Loot.OnClientEvent:Connect(function(item)
if typeof(item) ~= "table" or not item.id then
return
end
local inventory = UIState.get("inventory") or {}
local stacked = false
for _, held in inventory do
if held.id == item.id then
held.quantity = (held.quantity or 1) + (item.quantity or 1)
stacked = true
break
end
end
if not stacked then
table.insert(inventory, item)
end
UIState.set("inventory", inventory)
UI.Toast.push({
title = item.name,
subtitle = if stacked then "Added to your bag" else "New item",
kind = if item.rarity == "Common" then "loot" else "quest",
duration = 3,
})
end)
Network.EnemyDefeated.OnClientEvent:Connect(function(_id, rewardXp)
Leveling.addExperience(rewardXp or 0)
end)
UserInputService.InputBegan:Connect(function(input, processed)
if processed then
return
end
if Bindings.matches("attack", input) then
requestSwing()
elseif Bindings.matches("block", input) then
setBlocking(true)
elseif Bindings.matches("parry", input) then
requestParry()
end
end)
UserInputService.InputEnded:Connect(function(input)
if Bindings.matches("block", input) then
setBlocking(false)
end
end)
RunService.RenderStepped:Connect(function()
-- Hitstop: hold the arm exactly where it was. The pause is the point.
if os.clock() >= freezeUntil then
poseArm()
-- Recovery is cancellable. A buffered press fires the moment the
-- strike has landed rather than waiting for the arm to finish
-- returning — that gap is the difference between a chain that
-- feels snappy and one that feels like wading.
local chainable = swing == nil
if swing then
local s = swing.step
chainable = os.clock() - swing.startedAt >= s.windup + s.active
end
if chainable and bufferedAt > 0 then
local fresh = os.clock() - bufferedAt <= ATTACK.bufferWindow
bufferedAt = 0
if fresh then
beginSwing()
end
end
end
end)
UIState.observe("dead", function(dead)
if not dead then
return
end
setBlocking(false)
swing, comboIndex, bufferedAt = nil, 0, 0
task.delay(1.2, function()
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if root then
local y = World.groundHeight(World.Spawn.X, World.Spawn.Z)
root.CFrame = CFrame.new(World.Spawn.X, y + 5, World.Spawn.Z) * CFrame.Angles(0, math.pi, 0)
end
end)
end)
end
return Combat
]]>
-
Feel
0.35 then
Vfx.ring(at + Vector3.new(0, 0.12, 0), 2 + force * 5, surface.dust, 0.3)
end
if force > 0.7 then
-- Only a genuinely bad landing throws debris and holds the camera low.
Vfx.landing(at, force * 1.4)
dipHold = Config.Landing.stagger * force
end
dip = Config.Landing.dip * force
ScreenFx.shake(Config.Landing.shake * force)
Audio.playAt(if force > 0.6 then "heavyLand" else "land", at)
end
--------------------------------------------------------------------------------
-- Footsteps
--------------------------------------------------------------------------------
local function footstep(sprinting: boolean)
local surface, at = surfaceUnder()
if not at then
return
end
Audio.playAt(surface.cue, at)
local scale = (if sprinting then Config.Steps.sprintDustScale else Config.Steps.dustScale) * surface.dustiness
if scale > 0.08 then
Vfx.dust(at, scale)
end
end
--------------------------------------------------------------------------------
-- Per-frame
--------------------------------------------------------------------------------
local function step(dt: number)
if not (humanoid and root and humanoid.Health > 0) then
return
end
local position = root.Position
local velocity = root.AssemblyLinearVelocity
local planar = Vector3.new(velocity.X, 0, velocity.Z).Magnitude
local sprinting = UIState.get("sprinting") == true
local grounded = humanoid.FloorMaterial ~= Enum.Material.Air
------------------------------------------------------------------------
-- Airtime and landing
------------------------------------------------------------------------
if not grounded then
airborneFrom = math.max(airborneFrom or position.Y, position.Y)
wasAirborne = true
elseif wasAirborne then
wasAirborne = false
land(math.max((airborneFrom or position.Y) - position.Y, 0))
airborneFrom = nil
strideCarry = 0
end
------------------------------------------------------------------------
-- Footsteps, by distance rather than by timer
------------------------------------------------------------------------
if lastPosition and grounded then
local travelled = (Vector3.new(position.X, 0, position.Z) - Vector3.new(lastPosition.X, 0, lastPosition.Z)).Magnitude
-- Ignore teleports; they are not walking.
if travelled < 8 then
strideCarry += travelled
end
local stride = if sprinting then Config.Steps.sprintStride else Config.Steps.stride
if strideCarry >= stride and planar > 1 then
strideCarry -= stride
footstep(sprinting)
end
end
lastPosition = position
------------------------------------------------------------------------
-- Lean. The cheapest fix for "sliding statue".
------------------------------------------------------------------------
if waist and waistRest then
local facing = root.CFrame.LookVector
facing = Vector3.new(facing.X, 0, facing.Z)
local targetRoll, targetPitch = 0, 0
if lastFacing and facing.Magnitude > 0.01 and planar > 1.5 then
-- Signed turn rate: which way, and how hard.
local cross = lastFacing.X * facing.Z - lastFacing.Z * facing.X
local rate = math.clamp((cross / dt) / Config.Lean.maxTurnRate, -1, 1)
targetRoll = -rate * Config.Lean.turn
targetPitch = (planar / 26) * Config.Lean.sprint
end
if UIState.get("blocking") then
targetPitch = Config.Lean.guard
end
lastFacing = if facing.Magnitude > 0.01 then facing.Unit else lastFacing
local alpha = 1 - (1 - 0.12) ^ (dt * 60 * Config.Lean.responsiveness / 7)
leanRoll += (targetRoll - leanRoll) * alpha
leanPitch += (targetPitch - leanPitch) * alpha
waist.C0 = waistRest * CFrame.Angles(math.rad(leanPitch), 0, math.rad(leanRoll))
end
------------------------------------------------------------------------
-- Camera
------------------------------------------------------------------------
-- Sprint FOV: speed you can feel rather than measure.
ScreenFx.setSustainedFov(if sprinting then Config.Camera.sprintFov else 0)
if dipHold > 0 then
dipHold -= dt
elseif dip > 0.001 then
dip = math.max(dip - dt * Config.Landing.dipRecover, 0)
end
swayClock += dt * (1 + planar / 20)
local sway = Vector3.new(
math.sin(swayClock * Config.Camera.idleRate * 0.7) * Config.Camera.moveSway * math.min(planar / 16, 1),
math.sin(swayClock * Config.Camera.idleRate) * Config.Camera.idleSway - dip,
0
)
ScreenFx.setCameraOffset(sway)
ScreenFx.setSpeedLines(if sprinting then Config.SpeedLines.opacity else 0)
end
--------------------------------------------------------------------------------
function Feel.start()
if player.Character then
task.spawn(bind, player.Character)
end
player.CharacterAdded:Connect(bind)
RunService.RenderStepped:Connect(function(dt)
local ok, err = pcall(step, dt)
if not ok then
-- Presentation must never take the game down with it.
warn(`[Feel] {err}`)
end
end)
end
return Feel
]]>
-
Haptics
-
Interact
= nextScan then
nextScan = os.clock() + SCAN_INTERVAL
rescan()
end
-- A conversation already open owns the prompt; suppressing it stops the
-- hint flickering behind the panel you're reading.
if Dialogue.isOpen or Shop.isOpen or Craft.isOpen then
setTarget(nil)
return
end
local from = rootPosition()
if not from then
setTarget(nil)
return
end
local best, bestDistance = nil, RANGE
for _, model in targets do
local part = model.PrimaryPart
if part then
local distance = (part.Position - from).Magnitude
if distance < bestDistance then
best, bestDistance = model, distance
end
end
end
setTarget(best)
end
--------------------------------------------------------------------------------
-- Server-issued effects
--------------------------------------------------------------------------------
--[[
Health and stamina still live in the client store (see Network.luau's
header — the whole vitals path is client-owned for the slice). So a heal
the server authorised is applied here, on its instruction, rather than
being pushed as a value. Same trust level as everything else in that path;
it moves server-side with the rest of it.
]]
local function applyEffect(effect: string?)
if effect == "heal" then
UIState.set("health", UIState.get("maxHealth"))
Toast.push({ title = "Fully healed", kind = "levelup" })
elseif effect == "rest" then
UIState.patch({
health = UIState.get("maxHealth"),
stamina = UIState.get("maxStamina"),
})
Toast.push({ title = "Rested", subtitle = "Health and stamina restored", kind = "levelup" })
end
end
--------------------------------------------------------------------------------
-- Guidance
--------------------------------------------------------------------------------
--[[
Picks the one thing the player should be walking toward.
Priority is strict and deliberate: a quest ready to hand in beats a quest
in progress, which beats a quest waiting to be offered. Only ever one
marker — two arrows is the same as none, because the player has to stop
and decide which to believe.
Resolves the giver's live model rather than their scheduled position, so
the arrow follows the smith home at seven rather than pointing at an empty
anvil.
]]
local GUIDANCE_INTERVAL = 0.4
local nextGuidance = 0
local function npcModel(npcId: string): Model?
for _, model in targets do
if model:GetAttribute("NpcId") == npcId then
return model
end
end
return nil
end
local function updateGuidance()
if os.clock() < nextGuidance then
return
end
nextGuidance = os.clock() + GUIDANCE_INTERVAL
-- A conversation is open: the player is already where they need to be.
if Dialogue.isOpen or Shop.isOpen or Craft.isOpen then
Waypoint.clear()
return
end
local states = UIState.get("quests") or {}
local progress = UIState.get("questProgress") or {}
local best, bestKind
for _, quest in Town.Quests do
local state = states[quest.id]
if state == "active" and (progress[quest.id] or 0) >= quest.objective.count then
best, bestKind = quest, "turnin"
break
end
end
if not best then
for _, quest in Town.Quests do
if not states[quest.id] and (not quest.requires or states[quest.requires] == "done") then
best, bestKind = quest, "quest"
break
end
end
end
if not best then
Waypoint.clear()
return
end
local model = npcModel(best.giver)
local part = model and model.PrimaryPart
if not part then
-- The giver is indoors or out of range; nothing useful to point at.
Waypoint.clear()
return
end
local npc = Town.findNpc(best.giver)
Waypoint.set(
part.Position,
if bestKind == "turnin" then `Hand in: {best.name}` else `{(npc and npc.name) or "?"} — {best.name}`,
bestKind
)
end
--------------------------------------------------------------------------------
-- The Colosseum floor
--------------------------------------------------------------------------------
--[[
Stepping onto the sand starts a run.
No confirmation dialog. OiKatzo already explained the rules at the gate,
the causeway is a long deliberate walk, and a "are you sure?" box in front
of an arena floor is the game asking a question the player answered by
walking there. Leaving the floor ends the run, which is the same contract
stated the other way round.
]]
local arenaInside = false
local function watchArena()
local at = rootPosition()
if not at then
return
end
local flat = Vector3.new(at.X - Town.Colosseum.center.X, 0, at.Z - Town.Colosseum.center.Z)
local inside = flat.Magnitude < Town.Colosseum.radius - 6
if inside ~= arenaInside then
arenaInside = inside
Network.Arena:FireServer(if inside then "start" else "leave")
end
end
--------------------------------------------------------------------------------
function Interact.start()
prompt = Create("BillboardGui", {
Name = "InteractPrompt",
Size = UDim2.fromOffset(230, 32),
StudsOffsetWorldSpace = Vector3.new(0, 12.4, 0),
AlwaysOnTop = true,
LightInfluence = 0,
Enabled = false,
Parent = player:WaitForChild("PlayerGui"),
Create("Frame", {
Name = "Backing",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.15,
BorderSizePixel = 0,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Accent, Thickness = 1, Transparency = 0.35 }),
}),
})
-- Inside the backing rather than beside it: siblings at equal ZIndex draw
-- in creation order, which is not a thing to stake a prompt on.
promptLabel = Create("TextLabel", {
Name = "Label",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.Text,
Parent = prompt.Backing,
})
RunService.Heartbeat:Connect(tick)
RunService.Heartbeat:Connect(watchArena)
RunService.Heartbeat:Connect(updateGuidance)
UserInputService.InputBegan:Connect(function(input, processed)
if processed or not Bindings.matches("interact", input) then
return
end
if UIState.get("phase") ~= "playing" then
return
end
-- Not through an open menu. On a gamepad this is load-bearing: interact
-- and cancel are both B, and without the guard closing the inventory
-- would also start a conversation with whoever you happened to be
-- standing next to. It is right on a keyboard too, where talking to a
-- shopkeeper from behind your own inventory screen was merely strange.
if UIState.get("menuOpen") then
return
end
local model = current
if model then
Network.Interact:FireServer(model:GetAttribute("NpcId"), "talk")
end
end)
----------------------------------------------------------------------
-- Server state
----------------------------------------------------------------------
Network.Profile.OnClientEvent:Connect(function(profile)
UIState.patch({
gold = profile.gold,
materials = profile.materials,
ownedItems = profile.items,
quests = profile.quests,
questProgress = profile.questProgress,
kills = profile.kills,
})
end)
Network.Dialogue.OnClientEvent:Connect(function(payload)
if payload and payload.effect then
applyEffect(payload.effect)
end
end)
Network.QuestUpdate.OnClientEvent:Connect(function(questId, state, progress)
local quest = Town.findQuest(questId)
if not quest then
return
end
if state == "accepted" then
Toast.push({ title = "Quest accepted", subtitle = quest.name, kind = "quest", duration = 5 })
elseif state == "progress" then
Toast.push({
title = quest.name,
subtitle = `{progress} / {quest.objective.count}`,
kind = "system",
duration = 3,
})
elseif state == "ready" then
Toast.push({
title = "Objective complete",
subtitle = `{quest.name} — return to {(Town.findNpc(quest.giver) or {}).name or "town"}`,
kind = "quest",
duration = 6,
})
elseif state == "done" then
Toast.push({ title = "Quest complete", subtitle = quest.name, kind = "levelup", duration = 6 })
end
end)
end
return Interact
]]>
-
Leveling
= required and safety < 200 do
experience -= required
Leveling.levelUp()
required = UIState.get("experienceToNext")
safety += 1
end
UIState.set("experience", experience)
end
--- Total points a character should have earned by their current level, used to
--- sanity-check saves later.
function Leveling.pointsEarnedBy(level: number): number
return level
end
function Leveling.start()
-- Make sure a fresh character's requirement matches the curve rather than
-- whatever placeholder the store shipped with.
UIState.set("experienceToNext", Leveling.requiredFor(UIState.get("level") or 1))
-- Unlocking a skill spends a point; nothing else should be able to leave
-- the loadout holding something that is no longer owned.
UIState.observe("unlockedSkills", function()
local loadout = UIState.get("loadout") or {}
local changed = false
for index = 1, #Skills.Slots do
local id = loadout[index]
if id and not Loadout.isUnlocked(id) then
loadout[index] = nil
changed = true
end
end
if changed then
UIState.set("loadout", loadout)
end
end)
end
return Leveling
]]>
-
MobRender
= nextScan then
nextScan = os.clock() + SCAN_INTERVAL
rescan()
end
local viewer = viewerPosition()
local clock = os.clock()
for model, entry in tracked do
local published = model:GetAttribute("NetCFrame")
if typeof(published) ~= "CFrame" then
continue
end
--[[
Error-scaled, frame-rate-independent easing.
`1 - (1 - rate)^(dt*60)` is the same form the Rig uses, and is what
makes a 30fps and a 144fps client converge at the same wall-clock
speed rather than the same number of frames.
]]
local gap = (published.Position - entry.current.Position).Magnitude
if gap > SNAP then
-- Teleport, respawn or leash. Interpolating across it would drag
-- the model through the world in a straight line.
entry.current = published
else
local urgency = math.clamp(gap / ERROR_FULL, 0, 1)
local rate = FOLLOW + (MAX_FOLLOW - FOLLOW) * urgency * urgency
local alpha = 1 - (1 - rate) ^ (dt * 60)
entry.current = entry.current:Lerp(published, math.clamp(alpha, 0, 1))
end
if viewer and (entry.current.Position - viewer).Magnitude > RENDER_RANGE then
continue
end
local animate = Anim[entry.animName] or Anim.goblin
local state = model:GetAttribute("NetState") or "idle"
local phase = model:GetAttribute("NetPhase") or 0
local rootOffset, parts, bodyScale, rate = animate(state, phase, clock, Net.signals(model))
local size = entry.scale
local scaled = if bodyScale then bodyScale * size else Vector3.new(size, size, size)
entry.rig:blend(entry.current * (rootOffset or CFrame.identity), parts, scaled, rate or 0.3, dt)
end
end
function MobRender.start()
RunService.RenderStepped:Connect(function(dt)
local ok, err = pcall(step, dt)
if not ok then
warn(`[MobRender] {err}`)
end
end)
end
return MobRender
]]>
-
Quality
0
bloom.Intensity = base.bloom * preset.bloom
end
local grade = effect("ColorCorrectionEffect", "Grade")
if grade then
-- Never disabled, only pulled toward neutral. Switching the grade off
-- outright changes every colour in the game at once, which reads as a
-- rendering bug rather than as a quality setting.
grade.Saturation = base.saturation * preset.grade
grade.Contrast = base.contrast * preset.grade
end
end
--- Index 1 is the lowest tier, #TIERS the highest — the inverse of the table's
--- order, which is written best-first for readability.
local function presetFor(index: number)
return TIERS[#TIERS - index + 1]
end
function Quality.start()
if started then
return
end
started = true
local bloom = effect("BloomEffect", "Glow")
local grade = effect("ColorCorrectionEffect", "Grade")
base.bloom = bloom and bloom.Intensity or 0.5
base.saturation = grade and grade.Saturation or -0.1
base.contrast = grade and grade.Contrast or 0.14
-- Touch devices start one tier down rather than discovering it the hard
-- way over the first ten seconds of play.
if UserInputService.TouchEnabled and not UserInputService.MouseEnabled then
current = math.max(#TIERS - 1, 1)
apply(current)
end
local elapsed = 0
RunService.Heartbeat:Connect(function(dt)
elapsed += dt
if elapsed < SETTLE or dt <= 0 or pinned then
return
end
smoothedFps += (1 / dt - smoothedFps) * math.min(dt * 2, 1)
local fps = smoothedFps
if fps < DROP_BELOW then
badFor += dt
goodFor = 0
elseif fps > RAISE_ABOVE then
goodFor += dt
badFor = 0
else
-- In between is neither evidence for nor against; decay both so a
-- single stutter inside an otherwise fine minute counts for nothing.
badFor = math.max(badFor - dt, 0)
goodFor = math.max(goodFor - dt, 0)
end
if badFor >= DROP_AFTER and current > 1 then
current -= 1
badFor, goodFor = 0, 0
apply(current)
elseif goodFor >= RAISE_AFTER and current < #TIERS then
current += 1
badFor, goodFor = 0, 0
apply(current)
end
end)
end
--- Current tier name, for the settings readout and `/quality`.
function Quality.name(): string
local preset = presetFor(current)
return if preset then preset.name else "High"
end
function Quality.tier(): number
return current
end
--- Pin to a tier, for players who would rather choose. Stops the automatic
--- scaler from second-guessing them.
function Quality.set(tier: number)
pinned = true
current = math.clamp(math.floor(tier), 1, #TIERS)
badFor, goodFor = 0, 0
apply(current)
end
--- Hand control back to the scaler.
function Quality.auto()
pinned = false
badFor, goodFor = 0, 0
end
function Quality.isPinned(): boolean
return pinned
end
return Quality
]]>
-
Sprint
MOVE_EPSILON
local guarding = UIState.get("blocking") == true
-- No sprinting behind a raised guard. Committing to defence should
-- cost mobility, or blocking would be strictly free.
local sprinting = playing and moving and sprintHeld and not guarding and not exhausted and stamina > 0
if sprinting then
stamina = math.max(stamina - DRAIN_PER_SECOND * dt, 0)
lastDrainAt = os.clock()
if stamina <= 0 then
exhausted = true
sprinting = false
end
elseif stamina < maxStamina and os.clock() - lastDrainAt >= REGEN_DELAY then
stamina = math.min(stamina + REGEN_PER_SECOND * dt, maxStamina)
end
if exhausted and stamina >= RECOVERY_THRESHOLD then
exhausted = false
end
if Sprint.IsSprinting ~= sprinting then
UIState.set("sprinting", sprinting)
end
Sprint.IsSprinting = sprinting
-- The front-end holds the body still. Latched, so the jump property is
-- only touched when the state actually flips.
if frozen ~= not playing then
frozen = not playing
applyFreeze(frozen)
end
if humanoid and playing then
local target = if sprinting then SPRINT_SPEED elseif guarding then Encounters.Block.moveSpeed else WALK_SPEED
-- Focus slows you a little. Enough to sell the concentration, not
-- enough to make dodging out of the way feel broken.
if UIState.get("focusing") then
target *= Assist.MoveScale
end
if humanoid.WalkSpeed ~= target then
humanoid.WalkSpeed = target
end
end
-- Skip the write when idle at full stamina, so observers aren't woken
-- 60 times a second for nothing.
if math.abs(stamina - previous) > 0.001 then
UIState.set("stamina", stamina)
end
end)
end
return Sprint
]]>
-
Status
-
Townsfolk
= nextScan then
nextScan = os.clock() + SCAN_INTERVAL
rescan()
end
local hour = Lighting.ClockTime
local viewer = characterPosition()
for _, entry in residents do
local scheduled = Town.scheduleAt(entry.npc, hour)
local target = scheduled.at + V(0, Town.Floor, 0)
local delta = target - entry.position
local distance = delta.Magnitude
local moving = distance > 1.2
if moving then
entry.position += delta.Unit * math.min(WALK_SPEED * dt, distance)
entry.cframe = CFrame.lookAt(entry.position, entry.position + delta.Unit)
else
entry.position = target
entry.cframe = CFrame.lookAt(entry.position, entry.position + scheduled.facing)
end
--[[
Hiding is client-side now, via LocalTransparencyModifier rather than
Transparency. The server no longer touches these parts at all, so
using the replicated property would be a client writing state the
server believes it owns — and it would fight the moment anything
else replicated.
]]
setHidden(entry, (scheduled.state == "home" or scheduled.state == "sleep") and not moving)
-- Cull posing by distance. Position still updates so nobody teleports
-- when they come back into range.
if viewer and (entry.position - viewer).Magnitude > ANIMATE_RANGE then
continue
end
pose(entry, dt, moving)
end
end
function Townsfolk.start()
RunService.RenderStepped:Connect(function(dt)
local ok, err = pcall(step, dt)
if not ok then
warn(`[Townsfolk] {err}`)
end
end)
end
return Townsfolk
]]>
-
Tutorial
= (step.goal.count or 1)
end
local function setProgress(value: number)
if not step or advancing then
return
end
progress = value
UI.Objective.setProgress(progress / (step.goal.count or 1))
end
local function bump(amount: number?)
setProgress(progress + (amount or 1))
end
local function finish()
active = false
step = nil
Network.TutorialDrill:FireServer(nil)
UI.Objective.setObjective(nil)
UI.Objective.hideDialogue()
local reward = Config.Reward
local titles = UIState.get("earnedTitles") or {}
if reward.title and not table.find(titles, reward.title) then
table.insert(titles, reward.title)
end
UIState.patch({
tutorialDone = true,
earnedTitles = titles,
skillPoints = (UIState.get("skillPoints") or 0) + reward.skillPoints,
-- Parry is *taught* here, so it is granted rather than bought.
parryRank = math.max(UIState.get("parryRank") or 0, reward.parryRank),
})
UI.Toast.push({ title = "Training complete", subtitle = "Parry unlocked", kind = "levelup", duration = 6 })
task.delay(0.6, function()
Leveling.addExperience(reward.experience)
end)
end
--- Hands over whatever this step is about to teach. A lesson cannot teach a
--- tool the player does not have.
local function applyGrant(grant)
if not grant then
return
end
if grant.skill then
local unlocked = UIState.get("unlockedSkills") or {}
if not table.find(unlocked, grant.skill) then
table.insert(unlocked, grant.skill)
UIState.set("unlockedSkills", unlocked)
end
if grant.slot then
local loadout = UIState.get("loadout") or {}
-- Only fills an empty slot: never overwrite a returning player's
-- own choice with the tutorial's.
if not loadout[grant.slot] then
loadout[grant.slot] = grant.skill
UIState.set("loadout", loadout)
end
end
end
if grant.parryRank then
UIState.set("parryRank", math.max(UIState.get("parryRank") or 0, grant.parryRank))
end
end
local function beginStep(index: number)
-- Whatever drill the previous step was running, stop it.
Network.TutorialDrill:FireServer(nil)
stepIndex = index
step = Config.Steps[index]
progress = 0
advancing = false
if not step then
finish()
return
end
applyGrant(step.grant)
if step.drill then
Network.TutorialDrill:FireServer(step.drill)
end
UI.Objective.say(Config.Instructor.name, step.say)
UI.Objective.setObjective(step.objective, index, #Config.Steps)
UI.Objective.setProgress(0)
-- Reset per-step trackers.
lastPosition = nil
blockHeld = 0
sprintHeld = 0
end
local function advance()
if advancing or not step then
return
end
advancing = true
local closing = step.done
UI.Objective.setProgress(1)
UI.Objective.say(Config.Instructor.name, closing)
task.delay(2.4, function()
if active then
beginStep(stepIndex + 1)
end
end)
end
--------------------------------------------------------------------------------
-- Signals
--------------------------------------------------------------------------------
local function onKind(kind: string, amount: number?)
if not step or advancing or step.goal.kind ~= kind then
return
end
bump(amount)
if objectiveDone() then
advance()
end
end
function Tutorial.start()
-- Only guided origins run this. Traveler gets nothing and likes it.
UIState.observe("character", function(character)
local origin = Characters.findOrigin(character and character.origin)
if not origin or not origin.tutorial then
return
end
if active or UIState.get("tutorialDone") then
return
end
active = true
task.delay(1.2, function()
beginStep(1)
end)
end)
-- Anything at all skips the typewriter; specific things advance steps.
UserInputService.InputBegan:Connect(function(input, processed)
UI.Objective.skipTyping()
if processed or not active then
return
end
if input.KeyCode == Enum.KeyCode.Space then
onKind("jump")
elseif
input.UserInputType == Enum.UserInputType.MouseButton1
or input.KeyCode == Enum.KeyCode.E
or input.KeyCode == Enum.KeyCode.Return
then
-- Click, E or Enter all acknowledge her. Whichever you reach for
-- first is the right one.
onKind("talk")
end
end)
-- Server-side training-yard events.
Network.TutorialHit.OnClientEvent:Connect(function(kind)
if kind == "enemyDown" then
onKind("enemy")
else
onKind(kind)
end
end)
-- Parry confirmations come through the impact channel.
Network.Impact.OnClientEvent:Connect(function(kind)
if kind == "parry" then
onKind("parry")
end
end)
-- Dashing is an ability cast; only Quickstep counts.
UI.Events.AbilityCast:Connect(function(_slot, skill)
if skill and skill.id == "step" then
onKind("dodge")
end
end)
UIState.observe("menuOpen", function(mode)
if mode == "menu" then
onKind("menu")
end
end)
RunService.Heartbeat:Connect(function(dt)
if not active or not step or advancing then
return
end
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not root then
return
end
local kind = step.goal.kind
if kind == "move" then
if lastPosition then
local moved = (root.Position - lastPosition).Magnitude
-- Ignore teleports and falls; this should measure walking.
if moved < 6 then
bump(moved)
end
end
lastPosition = root.Position
if objectiveDone() then
advance()
end
elseif kind == "sprint" then
if UIState.get("sprinting") then
sprintHeld += dt
setProgress(sprintHeld)
if objectiveDone() then
advance()
end
end
elseif kind == "block" then
if UIState.get("blocking") then
blockHeld += dt
setProgress(blockHeld)
if objectiveDone() then
advance()
end
end
end
end)
-- Skills.Core is referenced so the tutorial's parry step and the menu's
-- core-skill entry can never drift apart silently.
assert(Skills.findCore("parry"), "Tutorial expects a core parry skill")
end
return Tutorial
]]>
-
Main
-
UI
-
Components
-
Bar
1 then
self:_buildSegments(config.Segments)
end
if config.ShowText then
self._label = Create("TextLabel", {
Name = "Value",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
TextSize = config.TextSize or 13,
TextColor3 = Theme.Color.Text,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.4,
TextXAlignment = Enum.TextXAlignment.Right,
Text = "",
ZIndex = 6,
Parent = self.Root,
Create("UIPadding", { PaddingRight = UDim.new(0, 8) }),
})
end
return self
end
function Bar:_buildSegments(count: number)
for index = 1, count - 1 do
Create("Frame", {
Name = `Tick{index}`,
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.fromScale(index / count, 0),
Size = UDim2.new(0, 1, 1, 0),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
ZIndex = 6,
Parent = self.Root,
})
end
end
function Bar:_updatePulse()
local threshold = self._config.LowThreshold
if not threshold or threshold <= 0 then
return
end
local shouldPulse = self._fraction <= threshold and self._fraction > 0
if shouldPulse and not self._pulseTween then
self._pulse.BackgroundTransparency = 0.9
self._pulseTween = Motion.pulse(self._pulse, 0.5, { BackgroundTransparency = 0.7 })
elseif not shouldPulse and self._pulseTween then
self._pulseTween:Cancel()
self._pulseTween = nil
self._pulse.BackgroundTransparency = 1
end
end
--- Sets the bar to `current` out of `max`.
--- `instant` skips all animation (use on respawn / first paint).
function Bar:setValue(current: number, max: number?, instant: boolean?)
local maximum = max or self._max or 1
self._max = maximum
self._current = current
local fraction = if maximum > 0 then math.clamp(current / maximum, 0, 1) else 0
local previous = self._fraction
self._fraction = fraction
if self._label then
self._label.Text = `{math.floor(current + 0.5)} / {math.floor(maximum + 0.5)}`
end
-- Any in-flight chip drain is now stale.
if self._chipTween then
self._chipTween:Cancel()
self._chipTween = nil
end
self._chipToken += 1
local token = self._chipToken
if instant then
self._fill.Size = UDim2.fromScale(fraction, 1)
self._chip.Size = UDim2.fromScale(fraction, 1)
self._chipFraction = fraction
self:_updatePulse()
return
end
if fraction < previous then
-- Damage: fill drops now, chip hangs then drains after it.
Motion.to(self._fill, Theme.Time.Fast, { Size = UDim2.fromScale(fraction, 1) })
task.delay(Theme.Time.ChipHold, function()
if token ~= self._chipToken or not self._chip.Parent then
return
end
self._chipFraction = fraction
self._chipTween =
Motion.to(self._chip, Theme.Time.ChipDrain, { Size = UDim2.fromScale(fraction, 1) }, Theme.Ease.Exit)
end)
else
-- Gain: chip leads, fill catches up.
self._chip.Size = UDim2.fromScale(fraction, 1)
self._chipFraction = fraction
Motion.to(self._fill, Theme.Time.Base, { Size = UDim2.fromScale(fraction, 1) })
end
self:_updatePulse()
end
function Bar:setColor(color: Color3, instant: boolean?)
self._color = color
if instant then
self._fill.BackgroundColor3 = color
else
Motion.to(self._fill, Theme.Time.Base, { BackgroundColor3 = color })
end
end
function Bar:setVisible(visible: boolean)
self.Root.Visible = visible
end
function Bar:getFraction(): number
return self._fraction
end
function Bar:destroy()
if self._pulseTween then
self._pulseTween:Cancel()
end
if self._chipTween then
self._chipTween:Cancel()
end
self._chipToken += 1
self._trove:clean()
end
return Bar
]]>
-
Button
())?,
}
function Button.new(config: Config)
local self = setmetatable({}, Button)
self._trove = Trove.new()
self._enabled = true
self._variant = config.Variant or "ghost"
self._accent = config.AccentColor or Theme.Color.Accent
local size = config.Size or UDim2.fromOffset(200, MIN_TOUCH_TARGET)
-- Enforce the touch floor without overriding an intentionally bigger button.
if size.Y.Scale == 0 and size.Y.Offset < MIN_TOUCH_TARGET then
size = UDim2.new(size.X.Scale, size.X.Offset, 0, MIN_TOUCH_TARGET)
end
local isPrimary = self._variant == "primary"
self.Root = self._trove:add(Create("TextButton", {
Name = "Button",
Size = size,
Position = config.Position,
AnchorPoint = config.AnchorPoint,
LayoutOrder = config.LayoutOrder,
ZIndex = config.ZIndex or 1,
BackgroundColor3 = if isPrimary then self._accent else Theme.Color.PanelRaised,
BackgroundTransparency = if isPrimary then 0 else 0.25,
AutoButtonColor = false,
BorderSizePixel = 0,
FontFace = Theme.Font.SemiBold,
Text = string.upper(config.Text),
TextSize = 14,
TextColor3 = if isPrimary then Theme.Color.TextInverse else Theme.Color.Text,
Parent = config.Parent,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
}))
self._stroke = Create("UIStroke", {
Color = if isPrimary then self._accent else Theme.Color.Stroke,
Thickness = 1,
Transparency = if isPrimary then 1 else 0.3,
Parent = self.Root,
})
self._trove:connect(self.Root.MouseEnter, function()
if self._enabled then
Audio.play("uiHover")
end
self:_setHover(true)
end)
self._trove:connect(self.Root.MouseLeave, function()
self:_setHover(false)
self:_setPressed(false)
end)
self._trove:connect(self.Root.MouseButton1Down, function()
self:_setPressed(true)
end)
self._trove:connect(self.Root.MouseButton1Up, function()
self:_setPressed(false)
end)
self._trove:connect(self.Root.Activated, function()
if self._enabled then
Audio.play("uiSelect")
end
if self._enabled and config.OnClick then
config.OnClick()
end
end)
return self
end
function Button:_setHover(hovering: boolean)
if not self._enabled then
return
end
if self._variant == "primary" then
Motion.to(self.Root, Theme.Time.Fast, {
BackgroundTransparency = if hovering then 0.1 else 0,
})
else
Motion.to(self.Root, Theme.Time.Fast, {
BackgroundTransparency = if hovering then 0.05 else 0.25,
})
Motion.to(self._stroke, Theme.Time.Fast, {
Transparency = if hovering then 0 else 0.3,
Color = if hovering then self._accent else Theme.Color.Stroke,
})
end
end
function Button:_setPressed(pressed: boolean)
if not self._enabled then
return
end
-- Small inward nudge; reads as tactile without moving layout.
Motion.to(self.Root, Theme.Time.Instant, {
TextSize = if pressed then 13 else 14,
})
end
function Button:setEnabled(enabled: boolean)
self._enabled = enabled
self.Root.Active = enabled
self.Root.AutoButtonColor = false
Motion.to(self.Root, Theme.Time.Fast, {
TextTransparency = if enabled then 0 else 0.55,
BackgroundTransparency = if enabled then (if self._variant == "primary" then 0 else 0.25) else 0.7,
})
end
function Button:setText(text: string)
self.Root.Text = string.upper(text)
end
function Button:destroy()
self._trove:clean()
end
return Button
]]>
-
Choice
())?,
}
function Choice.new(config: Config)
local self = setmetatable({}, Choice)
self._trove = Trove.new()
self._selected = false
self._hovered = false
self._accent = config.AccentColor or Theme.Color.Accent
self._variant = config.Variant or "row"
local isTile = self._variant == "tile"
local defaultSize = if isTile then UDim2.fromOffset(150, 104) else UDim2.new(1, 0, 0, 58)
self.Root = self._trove:add(Create("TextButton", {
Name = config.Title,
Size = config.Size or defaultSize,
LayoutOrder = config.LayoutOrder,
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.45,
AutoButtonColor = false,
BorderSizePixel = 0,
Text = "",
Parent = config.Parent,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
}))
self._stroke = Create("UIStroke", {
Color = Theme.Color.Stroke,
Thickness = 1,
Transparency = 0.5,
Parent = self.Root,
})
-- The non-colour selection cue.
self._marker = Create("Frame", {
Name = "Marker",
Size = if isTile then UDim2.new(0, 0, 0, 2) else UDim2.new(0, 2, 0, 0),
Position = UDim2.fromScale(0, 0),
BackgroundColor3 = self._accent,
BorderSizePixel = 0,
Parent = self.Root,
})
if config.Glyph then
self._glyph = Create("TextLabel", {
Name = "Glyph",
Size = if isTile then UDim2.new(1, 0, 0, 40) else UDim2.fromOffset(48, 58),
Position = if isTile then UDim2.fromOffset(0, 14) else UDim2.fromOffset(4, 0),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = config.Glyph,
TextSize = if isTile then 28 else 22,
TextColor3 = Theme.Color.TextMuted,
Parent = self.Root,
})
end
local textLeft = if isTile then 0 else (if config.Glyph then 54 else 14)
local textTop = if isTile then 56 else 10
self._title = Create("TextLabel", {
Name = "Title",
Position = UDim2.fromOffset(textLeft, textTop),
Size = UDim2.new(1, -textLeft - 10, 0, 19),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = config.Title,
TextSize = 15,
TextColor3 = Theme.Color.Text,
TextXAlignment = if isTile then Enum.TextXAlignment.Center else Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
Parent = self.Root,
})
if config.Subtitle then
self._subtitle = Create("TextLabel", {
Name = "Subtitle",
Position = UDim2.fromOffset(textLeft, textTop + 19),
Size = UDim2.new(1, -textLeft - 10, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = config.Subtitle,
TextSize = 12,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = if isTile then Enum.TextXAlignment.Center else Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
Parent = self.Root,
})
end
self._trove:connect(self.Root.MouseEnter, function()
Audio.play("uiHover")
self._hovered = true
self:_render()
end)
self._trove:connect(self.Root.MouseLeave, function()
self._hovered = false
self:_render()
end)
-- Press state. Button has had one since it was written; Choice did not, so
-- the two most-clicked controls in the game responded differently to the
-- same click — one acknowledged the press, the other only the release.
-- A press that produces nothing until you let go reads as latency.
self._trove:connect(self.Root.MouseButton1Down, function()
Motion.to(self.Root, Theme.Time.Instant, { BackgroundTransparency = 0.05 })
end)
self._trove:connect(self.Root.MouseButton1Up, function()
self:_render()
end)
self._trove:connect(self.Root.Activated, function()
Audio.play("uiSelect")
if config.OnSelect then
config.OnSelect()
end
end)
self:_render(true)
return self
end
function Choice:_render(instant: boolean?)
local selected, hovered = self._selected, self._hovered
local duration = if instant then 0 else Theme.Time.Fast
local isTile = self._variant == "tile"
local background = if selected then 0.1 elseif hovered then 0.25 else 0.45
local strokeTransparency = if selected then 0 elseif hovered then 0.2 else 0.5
if instant then
self.Root.BackgroundTransparency = background
self._stroke.Transparency = strokeTransparency
self._stroke.Color = if selected then self._accent else Theme.Color.Stroke
else
Motion.to(self.Root, duration, { BackgroundTransparency = background })
Motion.to(self._stroke, duration, {
Transparency = strokeTransparency,
Color = if selected then self._accent else Theme.Color.Stroke,
})
end
-- Marker grows along the edge rather than fading, so it reads as a state
-- change even in a screenshot.
local markerSize = if isTile
then UDim2.new(if selected then 1 else 0, 0, 0, 2)
else UDim2.new(0, 2, if selected then 1 else 0, 0)
if instant then
self._marker.Size = markerSize
else
Motion.to(self._marker, duration, { Size = markerSize })
end
if self._glyph then
local glyphColor = if selected then self._accent else Theme.Color.TextMuted
if instant then
self._glyph.TextColor3 = glyphColor
else
Motion.to(self._glyph, duration, { TextColor3 = glyphColor })
end
end
end
function Choice:setSelected(selected: boolean)
if self._selected == selected then
return
end
self._selected = selected
self:_render()
end
function Choice:isSelected(): boolean
return self._selected
end
function Choice:destroy()
self._trove:clean()
end
return Choice
]]>
-
Meter
-
Panel
())?,
ZIndex: number?,
}
function Panel.new(config: Config)
local self = setmetatable({}, Panel)
self._trove = Trove.new()
self._config = config
self._open = false
self._accent = config.AccentColor or Theme.Color.Accent
self.Root = self._trove:add(Create("Frame", {
Name = "PanelRoot",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
Visible = false,
ZIndex = config.ZIndex or 1,
Parent = config.Parent,
}))
if config.Scrim then
self._scrim = Create("TextButton", {
Name = "Scrim",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Scrim,
BackgroundTransparency = 1,
BorderSizePixel = 0,
AutoButtonColor = false,
Text = "",
ZIndex = 1,
Parent = self.Root,
Activated = function()
if config.OnClose then
config.OnClose()
end
end,
})
end
self.Window = Create("Frame", {
Name = "Window",
Size = config.Size,
Position = config.Position or UDim2.fromScale(0.5, 0.5),
AnchorPoint = config.AnchorPoint or Vector2.new(0.5, 0.5),
BackgroundColor3 = Theme.Color.Panel,
BorderSizePixel = 0,
ZIndex = 2,
Parent = self.Root,
Create("UICorner", { CornerRadius = Theme.Radius.lg }),
Create("UIStroke", {
Color = Theme.Color.Stroke,
Thickness = 1,
Transparency = 0.2,
}),
})
-- Thin accent rule along the top edge; the panel's only real colour.
Create("Frame", {
Name = "AccentRule",
Size = UDim2.new(1, 0, 0, 2),
BackgroundColor3 = self._accent,
BorderSizePixel = 0,
ZIndex = 4,
Parent = self.Window,
Create("UIGradient", {
Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.5, 0),
NumberSequenceKeypoint.new(1, 1),
}),
}),
})
local contentTop = Theme.Space.lg
if config.Title then
contentTop = 74
Create("TextLabel", {
Name = "Title",
Position = UDim2.fromOffset(Theme.Space.lg, Theme.Space.lg),
Size = UDim2.new(1, -Theme.Space.lg * 2, 0, 24),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.upper(config.Title),
TextSize = 19,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
ZIndex = 3,
Parent = self.Window,
})
if config.Subtitle then
Create("TextLabel", {
Name = "Subtitle",
Position = UDim2.fromOffset(Theme.Space.lg, Theme.Space.lg + 26),
Size = UDim2.new(1, -Theme.Space.lg * 2, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = config.Subtitle,
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
ZIndex = 3,
Parent = self.Window,
})
end
if config.OnClose then
-- Built then wired, rather than via Create's event sugar: MouseEnter
-- passes cursor coordinates, so a handler can't reach the button
-- through its arguments.
local closeButton = Create("TextButton", {
Name = "Close",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.new(1, -Theme.Space.md, 0, Theme.Space.md),
Size = UDim2.fromOffset(34, 34),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 1,
AutoButtonColor = false,
FontFace = Theme.Font.Bold,
Text = "✕",
TextSize = 15,
TextColor3 = Theme.Color.TextMuted,
ZIndex = 5,
Parent = self.Window,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
})
self._trove:connect(closeButton.Activated, config.OnClose)
self._trove:connect(closeButton.MouseEnter, function()
Motion.to(closeButton, Theme.Time.Fast, {
BackgroundTransparency = 0,
TextColor3 = Theme.Color.Text,
})
end)
self._trove:connect(closeButton.MouseLeave, function()
Motion.to(closeButton, Theme.Time.Fast, {
BackgroundTransparency = 1,
TextColor3 = Theme.Color.TextMuted,
})
end)
end
end
self.Content = Create("Frame", {
Name = "Content",
Position = UDim2.fromOffset(0, contentTop),
Size = UDim2.new(1, 0, 1, -contentTop),
BackgroundTransparency = 1,
ZIndex = 3,
Parent = self.Window,
})
return self
end
function Panel:isOpen(): boolean
return self._open
end
--- Title and subtitle are usually fixed, but menus that show live character
--- details need to rewrite them after construction.
function Panel:setTitle(text: string)
local label = self.Window:FindFirstChild("Title")
if label then
label.Text = string.upper(text)
end
end
function Panel:setSubtitle(text: string)
local label = self.Window:FindFirstChild("Subtitle")
if label then
label.Text = text
end
end
function Panel:open()
if self._open then
return
end
self._open = true
Audio.play("uiOpen")
self.Root.Visible = true
self.Window.Size = UDim2.new(
self._config.Size.X.Scale,
self._config.Size.X.Offset,
self._config.Size.Y.Scale * 0.94,
self._config.Size.Y.Offset * 0.94
)
Motion.pop(self.Window, Theme.Time.Slow, { Size = self._config.Size })
if self._scrim then
self._scrim.BackgroundTransparency = 1
Motion.to(self._scrim, Theme.Time.Base, { BackgroundTransparency = 0.45 })
end
end
function Panel:close()
if not self._open then
return
end
self._open = false
Audio.play("uiClose")
if self._scrim then
Motion.to(self._scrim, Theme.Time.Fast, { BackgroundTransparency = 1 })
end
local shrink = UDim2.new(
self._config.Size.X.Scale,
self._config.Size.X.Offset,
self._config.Size.Y.Scale * 0.96,
self._config.Size.Y.Offset * 0.96
)
local tween = Motion.to(self.Window, Theme.Time.Fast, { Size = shrink }, Theme.Ease.Exit)
tween.Completed:Once(function()
if not self._open then
self.Root.Visible = false
end
end)
end
function Panel:toggle()
if self._open then
self:close()
else
self:open()
end
end
function Panel:destroy()
self._trove:clean()
end
return Panel
]]>
-
Slider
())?,
}
local TRACK_HEIGHT = 4
local HANDLE = 14
local ROW_HEIGHT = 46
function Slider.new(config: Config)
local self = setmetatable({}, Slider)
self._trove = Trove.new()
self._accent = config.AccentColor or Theme.Color.Accent
self._step = config.Step or 0.05
self._value = math.clamp(config.Value or 1, 0, 1)
self._dragging = false
self._lastTickAt = 0
self._onChanged = config.OnChanged
self.Root = self._trove:add(Create("Frame", {
Name = config.Label,
Size = UDim2.new(1, 0, 0, if config.Summary then ROW_HEIGHT + 14 else ROW_HEIGHT),
BackgroundTransparency = 1,
LayoutOrder = config.LayoutOrder,
Parent = config.Parent,
}))
Create("TextLabel", {
Name = "Label",
Size = UDim2.new(1, -56, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = config.Label,
TextSize = 13,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = self.Root,
})
-- The readout. Percentages rather than decibels: this is a preference, not
-- a mixing desk, and nobody sets their music to -6 dB by choice.
self._readout = Create("TextLabel", {
Name = "Readout",
Size = UDim2.new(0, 52, 0, 18),
Position = UDim2.new(1, -52, 0, 0),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "100%",
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Right,
Parent = self.Root,
})
if config.Summary then
Create("TextLabel", {
Name = "Summary",
Position = UDim2.fromOffset(0, 18),
Size = UDim2.new(1, 0, 0, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = config.Summary,
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
Parent = self.Root,
})
end
-- A tall transparent button over a thin visible track, so the grab target
-- is a comfortable 24px while the track stays a 4px line.
self._hit = Create("TextButton", {
Name = "Hit",
Size = UDim2.new(1, 0, 0, 24),
Position = UDim2.new(0, 0, 1, -24),
BackgroundTransparency = 1,
AutoButtonColor = false,
Text = "",
Parent = self.Root,
})
self._track = Create("Frame", {
Name = "Track",
Size = UDim2.new(1, 0, 0, TRACK_HEIGHT),
Position = UDim2.new(0, 0, 0.5, -TRACK_HEIGHT / 2),
BackgroundColor3 = Theme.Color.PanelHover,
BorderSizePixel = 0,
Parent = self._hit,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
self._fill = Create("Frame", {
Name = "Fill",
Size = UDim2.fromScale(self._value, 1),
BackgroundColor3 = self._accent,
BorderSizePixel = 0,
Parent = self._track,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
self._handle = Create("Frame", {
Name = "Handle",
Size = UDim2.fromOffset(HANDLE, HANDLE),
Position = UDim2.new(self._value, -HANDLE / 2, 0.5, -HANDLE / 2),
BackgroundColor3 = Theme.Color.Text,
BorderSizePixel = 0,
Parent = self._hit,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
self._trove:connect(self._hit.MouseEnter, function()
Motion.to(self._handle, Theme.Time.Fast, { Size = UDim2.fromOffset(HANDLE + 3, HANDLE + 3) })
self:_reposition()
end)
self._trove:connect(self._hit.MouseLeave, function()
if not self._dragging then
Motion.to(self._handle, Theme.Time.Fast, { Size = UDim2.fromOffset(HANDLE, HANDLE) })
self:_reposition()
end
end)
self._trove:connect(self._hit.InputBegan, function(input)
if
input.UserInputType == Enum.UserInputType.MouseButton1
or input.UserInputType == Enum.UserInputType.Touch
then
self._dragging = true
self:_setFromInput(input.Position.X)
end
end)
-- Global, deliberately: see the header. The press is owned until it ends,
-- no matter where the pointer wanders.
self._trove:connect(UserInputService.InputChanged, function(input)
if not self._dragging then
return
end
if
input.UserInputType == Enum.UserInputType.MouseMovement
or input.UserInputType == Enum.UserInputType.Touch
then
self:_setFromInput(input.Position.X)
end
end)
self._trove:connect(UserInputService.InputEnded, function(input)
if not self._dragging then
return
end
if
input.UserInputType == Enum.UserInputType.MouseButton1
or input.UserInputType == Enum.UserInputType.Touch
then
self._dragging = false
Motion.to(self._handle, Theme.Time.Fast, { Size = UDim2.fromOffset(HANDLE, HANDLE) })
self:_reposition()
end
end)
self:_render(true)
return self
end
--- Handle position depends on its current size, so this is shared by every path
--- that changes either.
function Slider:_reposition()
local size = self._handle.Size.X.Offset
self._handle.Position = UDim2.new(self._value, -size / 2, 0.5, -size / 2)
end
function Slider:_setFromInput(x: number)
local left = self._track.AbsolutePosition.X
local width = self._track.AbsoluteSize.X
if width <= 0 then
return
end
local raw = math.clamp((x - left) / width, 0, 1)
local stepped = math.round(raw / self._step) * self._step
self:setValue(stepped, true)
end
function Slider:_render(instant: boolean?)
local duration = if instant then 0 else Theme.Time.Instant
if instant then
self._fill.Size = UDim2.fromScale(self._value, 1)
else
Motion.to(self._fill, duration, { Size = UDim2.fromScale(self._value, 1) })
end
self:_reposition()
self._readout.Text = `{math.round(self._value * 100)}%`
self._readout.TextColor3 = if self._value <= 0 then Theme.Color.TextDim else Theme.Color.TextMuted
end
--[[
`fromUser` separates a drag from a programmatic set: only a drag makes a
sound and reports back. Without it, restoring saved settings at boot would
fire the change handler for every slider and click five times.
]]
function Slider:setValue(value: number, fromUser: boolean?)
local clamped = math.clamp(value, 0, 1)
if math.abs(clamped - self._value) < 1e-4 then
return
end
self._value = clamped
self:_render()
if not fromUser then
return
end
-- Throttled, so dragging across the whole track is a run of ticks and not
-- a solid buzz.
local now = os.clock()
if now - self._lastTickAt > 0.04 then
self._lastTickAt = now
Audio.play("uiHover")
end
if self._onChanged then
self._onChanged(clamped)
end
end
function Slider:value(): number
return self._value
end
function Slider:destroy()
self._trove:clean()
end
return Slider
]]>
-
TextField
= 3, "At least 3 characters" end,
OnChanged = function(text, valid) ... end,
})
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Create = require(ReplicatedStorage.Shared.Util.Create)
local Motion = require(ReplicatedStorage.Shared.Util.Motion)
local Theme = require(ReplicatedStorage.Shared.Config.Theme)
local Trove = require(ReplicatedStorage.Shared.Util.Trove)
local TextField = {}
TextField.__index = TextField
export type Config = {
Parent: Instance,
Label: string?,
Placeholder: string?,
Text: string?,
MaxLength: number?,
Size: UDim2?,
Position: UDim2?,
LayoutOrder: number?,
--- Returns (isValid, message). Message shows in red when invalid, and as
--- a muted hint when valid.
Validate: ((text: string) -> (boolean, string?))?,
OnChanged: ((text: string, valid: boolean) -> ())?,
OnSubmit: ((text: string) -> ())?,
}
function TextField.new(config: Config)
local self = setmetatable({}, TextField)
self._trove = Trove.new()
self._config = config
self.Valid = false
local width = config.Size or UDim2.new(1, 0, 0, 74)
self.Root = self._trove:add(Create("Frame", {
Name = "TextField",
Size = width,
Position = config.Position,
LayoutOrder = config.LayoutOrder,
BackgroundTransparency = 1,
Parent = config.Parent,
}))
if config.Label then
Create("TextLabel", {
Name = "Label",
Size = UDim2.new(1, 0, 0, 15),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = string.upper(config.Label),
TextSize = 11,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = self.Root,
})
end
local box = Create("Frame", {
Name = "Box",
Position = UDim2.fromOffset(0, if config.Label then 19 else 0),
Size = UDim2.new(1, 0, 0, 40),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.25,
BorderSizePixel = 0,
Parent = self.Root,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
})
self._stroke = Create("UIStroke", {
Color = Theme.Color.Stroke,
Thickness = 1,
Transparency = 0.35,
Parent = box,
})
self.Input = Create("TextBox", {
Name = "Input",
Size = UDim2.new(1, -24, 1, 0),
Position = UDim2.fromOffset(12, 0),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = config.Text or "",
PlaceholderText = config.Placeholder or "",
PlaceholderColor3 = Theme.Color.TextDim,
TextSize = 15,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
ClearTextOnFocus = false,
Parent = box,
})
self._hint = Create("TextLabel", {
Name = "Hint",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.new(0, 0, 1, 0),
Size = UDim2.new(1, 0, 0, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = self.Root,
})
if config.MaxLength then
self._counter = Create("TextLabel", {
Name = "Counter",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(1, 0, 1, 0),
Size = UDim2.fromOffset(60, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Right,
Parent = self.Root,
})
end
self._trove:connect(self.Input:GetPropertyChangedSignal("Text"), function()
self:_onTextChanged()
end)
self._trove:connect(self.Input.Focused, function()
Motion.to(self._stroke, Theme.Time.Fast, { Color = Theme.Color.Accent, Transparency = 0 })
end)
self._trove:connect(self.Input.FocusLost, function(enterPressed)
Motion.to(self._stroke, Theme.Time.Fast, {
Color = if self.Valid then Theme.Color.Stroke else Theme.Color.Danger,
Transparency = 0.35,
})
if enterPressed and config.OnSubmit then
config.OnSubmit(self.Input.Text)
end
end)
self:_onTextChanged()
return self
end
function TextField:_onTextChanged()
local config = self._config
local text = self.Input.Text
-- Enforce the cap by rewriting, which re-enters this handler once and
-- then settles.
if config.MaxLength and #text > config.MaxLength then
self.Input.Text = string.sub(text, 1, config.MaxLength)
return
end
local valid, message = true, nil
if config.Validate then
valid, message = config.Validate(text)
end
self.Valid = valid
self._hint.Text = message or ""
self._hint.TextColor3 = if valid then Theme.Color.TextDim else Theme.Color.Danger
if self._counter then
self._counter.Text = `{#text}/{config.MaxLength}`
end
if config.OnChanged then
config.OnChanged(text, valid)
end
end
function TextField:getText(): string
return self.Input.Text
end
function TextField:setText(text: string)
self.Input.Text = text
end
function TextField:focus()
self.Input:CaptureFocus()
end
function TextField:destroy()
self._trove:clean()
end
return TextField
]]>
-
Core
-
Events
AbilityBar -> Abilities -> UI` would
be a cycle and Luau would refuse to load it.
Both sides require this instead. Nothing in here requires anything but
Signal, so it can never take part in a cycle.
]]
local Signal = require(game:GetService("ReplicatedStorage").Shared.Util.Signal)
local Events = {}
--- (slotIndex: number, skill: Skill)
Events.AbilityCast = Signal.new()
--- (slotIndex: number, reason: "locked" | "empty" | "cooldown" | "stamina")
Events.AbilityFailed = Signal.new()
return Events
]]>
-
Layer
-
Loadout
-
Responsive
viewport.X
-- min() of both axes: guarantees the reference frame always fits.
local scale = math.min(viewport.X / REFERENCE.X, viewport.Y / REFERENCE.Y)
if Responsive.IsTouch then
scale *= TOUCH_MULTIPLIER
end
return math.clamp(scale, MIN_SCALE, MAX_SCALE)
end
local function applyEntry(entry: Entry, scale: number)
entry.uiScale.Scale = scale
if entry.canvas then
-- Counter-size so canvas * scale == exactly one viewport.
entry.canvas.Size = UDim2.fromScale(1 / scale, 1 / scale)
end
end
local function apply(force: boolean?)
local scale = compute()
if not force and math.abs(scale - Responsive.Scale) < 0.001 then
return
end
Responsive.Scale = scale
for index = #registered, 1, -1 do
local entry = registered[index]
if entry.uiScale.Parent then
applyEntry(entry, scale)
else
table.remove(registered, index) -- layer was destroyed
end
end
Responsive.Changed:Fire(scale)
end
--- Registers a UIScale (and optionally the canvas frame holding it) to be
--- driven by this module.
function Responsive.register(uiScale: UIScale, canvas: Frame?)
local entry: Entry = { uiScale = uiScale, canvas = canvas }
table.insert(registered, entry)
applyEntry(entry, Responsive.Scale)
end
--- The inset the mobile controls occupy. Keep interactive UI out of the
--- bottom-left (thumbstick) and bottom-right (jump button).
function Responsive.controlSafeInset(): number
return if Responsive.IsTouch then 190 else 0
end
function Responsive.start()
Responsive.Scale = compute()
local function watchCamera()
local camera = Workspace.CurrentCamera
if camera then
camera:GetPropertyChangedSignal("ViewportSize"):Connect(function()
apply()
end)
end
end
watchCamera()
Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
watchCamera()
apply()
end)
-- Rotating a phone changes the usable area without always firing
-- ViewportSize on the same frame.
GuiService:GetPropertyChangedSignal("TopbarInset"):Connect(function()
apply()
end)
UserInputService:GetPropertyChangedSignal("TouchEnabled"):Connect(function()
Responsive.IsTouch = UserInputService.TouchEnabled and not UserInputService.MouseEnabled
apply(true)
end)
apply(true)
end
return Responsive
]]>
-
UIState
item id
equipment = {},
selectedItem = nil,
-- Progression. One point at level 1 so a new character has exactly one
-- meaningful choice to make, and one more per level after that.
skillPoints = 1,
--- Array of unlocked skill ids.
unlockedSkills = {},
selectedSkill = nil,
--- Three loadout slots, keyed Q/E/R. Holds skill ids or nil.
loadout = { nil, nil, nil },
--- Map of skill id -> os.clock() timestamp the cooldown ends.
cooldowns = {},
--- Map of scenario id -> state ("available" | "active" | "cleared" | "taken").
scenarioStates = {},
--- Array of earned title ids.
earnedTitles = {},
equippedTitle = nil,
-- Front-end flow: "boot" | "title" | "create" | "playing".
-- Gameplay UI (HUD, boss bar, menus) only appears in "playing".
phase = "boot",
--- { name, race, style } once created.
character = nil,
--- Guard raised. Read by Sprint so blocking slows you down.
blocking = false,
--- Sprinting right now. Read by the tutorial.
sprinting = false,
--- Guided start finished. Traveler origins never set this.
tutorialDone = false,
--- Gameplay setting: "off" | "adaptive" | "always".
parryHelper = "adaptive",
--- True while the focus assist is showing. Read by Sprint.
focusing = false,
--- Parry is a permanent, upgradeable core skill. 0 means not yet unlocked.
parryRank = 0,
--- os.clock() the parry comes off cooldown, and when its window closes.
parryReadyAt = 0,
parryWindowUntil = 0,
-- UI mode
menuOpen = nil, -- nil | "menu"
menuTab = "inventory", -- status | inventory | skills | scenarios | titles
dead = false,
deaths = 0,
}
local watchers: { [string]: { (value: any, old: any) -> () } } = {}
function UIState.get(key: string): any
return state[key]
end
--- Returns a shallow copy so callers can't mutate the store by accident.
function UIState.snapshot(): { [string]: any }
return table.clone(state)
end
function UIState.set(key: string, value: any)
local old = state[key]
-- Tables always re-fire. Callers routinely mutate a table in place (boss
-- health, status list) and hand back the same reference; comparing by
-- identity would silently swallow those updates.
if old == value and type(value) ~= "table" then
return
end
state[key] = value
local list = watchers[key]
if list then
for _, fn in list do
task.spawn(fn, value, old)
end
end
UIState.Changed:Fire(key, value, old)
end
--- Sets several keys at once.
function UIState.patch(values: { [string]: any })
for key, value in values do
UIState.set(key, value)
end
end
--- Calls `fn` immediately with the current value, then on every change.
--- Returns a disconnect function.
function UIState.observe(key: string, fn: (value: any, old: any) -> ()): () -> ()
local list = watchers[key]
if not list then
list = {}
watchers[key] = list
end
table.insert(list, fn)
task.spawn(fn, state[key], nil)
return function()
local current = watchers[key]
if not current then
return
end
local index = table.find(current, fn)
if index then
table.remove(current, index)
end
end
end
--- Observes several keys with one handler. Handler receives no arguments and
--- is expected to read what it needs via UIState.get.
function UIState.observeMany(keys: { string }, fn: () -> ()): () -> ()
local disconnects = {}
for _, key in keys do
table.insert(disconnects, UIState.observe(key, fn))
end
return function()
for _, disconnect in disconnects do
disconnect()
end
end
end
return UIState
]]>
-
Flow
title -> create -> playing
Owns the transitions between them and nothing else. Each screen exposes
show/hide and knows nothing about what comes before or after it, so the
order can be changed here alone -- e.g. skipping straight to `playing` for
a returning player once profiles exist.
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Items = require(ReplicatedStorage.Shared.Config.Items)
local Network = require(ReplicatedStorage.Shared.Network)
local UIState = require(script.Parent.Core.UIState)
local BootSequence = require(script.Parent.Screens.BootSequence)
local CharacterCreate = require(script.Parent.Screens.CharacterCreate)
local TitleScreen = require(script.Parent.Screens.TitleScreen)
local Toast = require(script.Parent.Overlays.Toast)
local Flow = {}
local function enter(phase: string)
UIState.set("phase", phase)
end
--- Applies the created character to the store and drops into gameplay.
--- Everyone starts armed: a style that leaves you punching air through your
--- first fight isn't a choice, it's a punishment.
local function beginPlaying(character)
local inventory = Items.startingInventory(character.style)
local weapon = Items.starterFor(character.style)
UIState.patch({
character = character,
displayName = character.name,
inventory = inventory,
equipment = { Weapon = weapon.id },
selectedItem = weapon.id,
})
-- The server builds the matching model and welds it on, so other players
-- see it too, and routes the spawn point from the chosen origin.
Network.CharacterChosen:FireServer(character)
Network.OriginChosen:FireServer(character.origin)
CharacterCreate.hide()
enter("playing")
task.delay(0.4, function()
Toast.push({
title = `Welcome, {character.name}`,
subtitle = "Shift to sprint · B for the character menu",
kind = "system",
duration = 6,
})
end)
end
function Flow.start()
BootSequence.start()
TitleScreen.start(function()
TitleScreen.hide()
enter("create")
CharacterCreate.show()
end)
CharacterCreate.start(beginPlaying)
enter("boot")
BootSequence.play(function()
enter("title")
TitleScreen.show()
end)
end
--- Replays the dive sequence from any phase and lands back on the title.
--- Only the sequence re-runs -- the screens themselves are already built, and
--- calling Flow.start() again would construct a second set of them.
function Flow.replayBoot()
TitleScreen.hide()
CharacterCreate.hide()
UIState.patch({ phase = "boot", menuOpen = nil, dead = false })
BootSequence.play(function()
enter("title")
TitleScreen.show()
end)
end
--- Jumps straight to gameplay with a stock character. Used by the sandbox so
--- UI work doesn't mean sitting through the dive sequence on every reload.
function Flow.skipToPlaying(character)
TitleScreen.hide()
CharacterCreate.hide()
local weapon = Items.starterFor(character.style)
UIState.patch({
character = character,
displayName = character.name,
phase = "playing",
-- Skipping creation still has to arm you, or the fight is unwinnable
-- for reasons that have nothing to do with the fight.
inventory = Items.startingInventory(character.style),
equipment = { Weapon = weapon.id },
selectedItem = weapon.id,
})
Network.CharacterChosen:FireServer(character)
Network.OriginChosen:FireServer(character.origin)
end
return Flow
]]>
-
Overlays
-
DamageNumbers
-
FocusFx
= 1 then
FocusFx.stop()
end
end)
end
--------------------------------------------------------------------------------
--- Shows the effect for `seconds`. `ring` and `prompt` come from the server's
--- stage decision; this module never escalates itself.
function FocusFx.show(seconds: number, strength: number, ring_: boolean?, prompt_: boolean?)
if seconds <= 0 then
return
end
active = true
startedAt = os.clock()
duration = seconds
visibility = math.clamp(strength, 0, 1)
showRing = ring_ == true
showPrompt = prompt_ == true
ringStroke.Transparency = 1
promptLabel.TextTransparency = 1
root.Visible = true
Audio.play("heartbeat")
end
function FocusFx.stop()
if not active then
return
end
active = false
root.Visible = false
ringStroke.Transparency = 1
promptLabel.TextTransparency = 1
desaturate.BackgroundTransparency = 1
vignette.BackgroundTransparency = 1
end
function FocusFx.isActive(): boolean
return active
end
return FocusFx
]]>
-
LevelUp
-
ScenarioBanner
rules sweep out from centre -> kicker fades up
-> name rises into place -> hold -> everything retreats
ScenarioBanner.play({
kicker = "Unique Scenario",
name = "Vorpal Bunny",
note = "First clear across all servers",
})
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Create = require(ReplicatedStorage.Shared.Util.Create)
local Motion = require(ReplicatedStorage.Shared.Util.Motion)
local Theme = require(ReplicatedStorage.Shared.Config.Theme)
local Layer = require(script.Parent.Parent.Core.Layer)
local RULE_WIDTH = 560
local HOLD = 2.1
local ScenarioBanner = {}
local root: Frame
local playToken = 0
export type Options = {
kicker: string?,
name: string,
note: string?,
color: Color3?,
hold: number?,
}
--- Letterspacing Roblox won't do for us. Cheap, and the kicker is short.
local function spaced(text: string): string
return table.concat(string.split(string.upper(text), ""), " ")
end
function ScenarioBanner.play(options: Options)
if not root then
return
end
playToken += 1
local token = playToken
local accent = options.color or Theme.Color.Unique
-- A fresh subtree per play; simpler than resetting a dozen properties and
-- guarantees an interrupted banner can't leak state into the next one.
root:ClearAllChildren()
local vignette = Create("Frame", {
Name = "Vignette",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Scrim,
BackgroundTransparency = 1,
BorderSizePixel = 0,
Parent = root,
})
local group = Create("Frame", {
Name = "Group",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.42),
Size = UDim2.fromOffset(RULE_WIDTH, 200),
BackgroundTransparency = 1,
Parent = root,
})
local function rule(yScale: number): Frame
return Create("Frame", {
Name = "Rule",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, yScale),
Size = UDim2.fromOffset(0, 1),
BackgroundColor3 = accent,
BorderSizePixel = 0,
Parent = group,
Create("UIGradient", {
Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.5, 0),
NumberSequenceKeypoint.new(1, 1),
}),
}),
})
end
local topRule = rule(0.16)
local bottomRule = rule(0.84)
local kicker = Create("TextLabel", {
Name = "Kicker",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.34),
Size = UDim2.fromScale(1, 0.16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = spaced(options.kicker or "Unique Scenario"),
TextSize = 15,
TextColor3 = accent,
TextTransparency = 1,
Parent = group,
})
local nameLabel = Create("TextLabel", {
Name = "ScenarioName",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.56),
Size = UDim2.fromScale(1, 0.32),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = string.upper(options.name),
TextSize = 52,
TextColor3 = Theme.Color.Text,
TextTransparency = 1,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.6,
Parent = group,
})
local note = if options.note
then Create("TextLabel", {
Name = "Note",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.95),
Size = UDim2.fromScale(1, 0.14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = options.note,
TextSize = 14,
TextColor3 = Theme.Color.TextMuted,
TextTransparency = 1,
Parent = group,
})
else nil
local function stillPlaying(): boolean
return token == playToken and root.Parent ~= nil
end
-- 1. Dim
Motion.to(vignette, Theme.Time.Slow, { BackgroundTransparency = 0.55 })
-- 2. Rules sweep outward
Motion.to(topRule, Theme.Time.Deliberate, { Size = UDim2.fromOffset(RULE_WIDTH, 1) }, Theme.Ease.Enter)
Motion.to(bottomRule, Theme.Time.Deliberate, { Size = UDim2.fromOffset(RULE_WIDTH, 1) }, Theme.Ease.Enter)
-- 3. Kicker
Motion.to(kicker, Theme.Time.Slow, { TextTransparency = 0 }, Theme.Ease.Standard, 0.22)
-- 4. Name rises in
task.delay(0.4, function()
if not stillPlaying() then
return
end
nameLabel.Position = UDim2.fromScale(0.5, 0.62)
Motion.to(nameLabel, Theme.Time.Deliberate, {
TextTransparency = 0,
Position = UDim2.fromScale(0.5, 0.56),
}, Theme.Ease.Enter)
if note then
Motion.to(note, Theme.Time.Slow, { TextTransparency = 0 }, Theme.Ease.Standard, 0.3)
end
end)
-- 5. Hold, then retreat
task.delay(0.4 + (options.hold or HOLD), function()
if not stillPlaying() then
return
end
Motion.to(vignette, Theme.Time.Deliberate, { BackgroundTransparency = 1 })
Motion.to(topRule, Theme.Time.Slow, { Size = UDim2.fromOffset(0, 1) }, Theme.Ease.Exit)
Motion.to(bottomRule, Theme.Time.Slow, { Size = UDim2.fromOffset(0, 1) }, Theme.Ease.Exit)
for _, label in { kicker, nameLabel, note } do
if label then
Motion.to(label, Theme.Time.Slow, { TextTransparency = 1 })
end
end
task.delay(Theme.Time.Deliberate + 0.1, function()
if token == playToken then
root:ClearAllChildren()
end
end)
end)
end
function ScenarioBanner.start()
root = Layer.root("Overlay", "ScenarioBanner")
end
return ScenarioBanner
]]>
-
ScreenFx
0.001 then
flash.BackgroundColor3 = flashColor
flash.BackgroundTransparency = 1 - flashAlpha
flashAlpha = math.max(flashAlpha - dt * 4.2, 0)
elseif flash.BackgroundTransparency < 1 then
flash.BackgroundTransparency = 1
end
if vignetteAlpha > 0.001 then
vignette.BackgroundTransparency = 1 - vignetteAlpha
vignetteAlpha = math.max(vignetteAlpha - dt * 1.6, 0)
elseif vignette.BackgroundTransparency < 1 then
vignette.BackgroundTransparency = 1
end
-- Eased, so a brief sprint doesn't strobe them on and off.
speedAlpha += (speedTarget - speedAlpha) * math.min(dt * 6, 1)
if speedAlpha > 0.005 then
for index, streak in streaks do
streak.BackgroundTransparency = 1 - speedAlpha * (0.6 + (index % 3) * 0.2)
end
else
for _, streak in streaks do
streak.BackgroundTransparency = 1
end
end
end)
--------------------------------------------------------------------------
-- Camera: after Roblox has placed it, or everything here is discarded.
--------------------------------------------------------------------------
RunService:BindToRenderStep("ShangriLaCamera", Enum.RenderPriority.Camera.Value + 1, function(dt)
local camera = Workspace.CurrentCamera
if not camera then
return
end
if not baseFov then
baseFov = camera.FieldOfView
end
if fovPunch ~= 0 then
fovPunch = fovPunch * (1 - math.min(dt * 5, 1))
if math.abs(fovPunch) < 0.05 then
fovPunch = 0
end
end
camera.FieldOfView = (baseFov or 70) + fovPunch + fovSustained
if surrendered then
return
end
-- Offsets are applied in camera space so a dip is always "down the
-- screen", regardless of which way the player is looking.
if cameraOffset.Magnitude > 0.001 then
camera.CFrame = camera.CFrame * CFrame.new(cameraOffset.X, cameraOffset.Y, cameraOffset.Z)
end
if shake > 0.01 then
local magnitude = shake * 0.12
camera.CFrame = camera.CFrame
* CFrame.new((math.random() - 0.5) * magnitude, (math.random() - 0.5) * magnitude, 0)
shake = math.max(shake - dt * 9, 0)
end
end)
end
--------------------------------------------------------------------------------
function ScreenFx.flash(color: Color3, strength: number)
flashColor = color
flashAlpha = math.max(flashAlpha, math.clamp(strength, 0, 1))
end
function ScreenFx.hurt(strength: number)
vignetteAlpha = math.max(vignetteAlpha, math.clamp(strength, 0, 0.85))
ScreenFx.flash(Color3.fromRGB(180, 20, 20), 0.35)
end
--- The parry: white pop, camera punches in, world holds still.
function ScreenFx.parry()
ScreenFx.flash(Color3.new(1, 1, 1), 0.9)
fovPunch = -14
end
function ScreenFx.push(amount: number)
fovPunch = amount
end
ScreenFx.Theme = Theme
return ScreenFx
]]>
-
Toast
MAX_VISIBLE do
dismiss(active[1])
end
task.delay(options.duration or LIFETIME, function()
if card.Parent then
dismiss(card)
end
end)
end
function Toast.start()
root = Layer.root("Overlay", "Toasts")
stack = Create("Frame", {
Name = "Stack",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.new(1, -26, 0, 150),
Size = UDim2.fromOffset(WIDTH, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
Parent = root,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
HorizontalAlignment = Enum.HorizontalAlignment.Right,
Padding = UDim.new(0, 8),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
end
return Toast
]]>
-
Waypoint
0 then
chevron.Visible = false
return
end
--[[
Project the target onto the screen edge.
WorldToViewportPoint gives a mirrored point when the target is behind
the camera (Z < 0), so that case is flipped explicitly. Getting this
wrong points the arrow at exactly the opposite of the objective, which
is worse than having no arrow at all.
]]
local viewport = camera.ViewportSize
local centre = Vector2.new(viewport.X / 2, viewport.Y / 2)
local screen = Vector2.new(point.X, point.Y)
if point.Z < 0 then
screen = centre - (screen - centre)
end
local direction = screen - centre
if direction.Magnitude < 1 then
direction = Vector2.new(0, 1)
end
direction = direction.Unit
-- Push out to the edge of an inset rectangle, whichever axis hits first.
local halfX = centre.X - EDGE_INSET
local halfY = centre.Y - EDGE_INSET
local scale = math.min(
if math.abs(direction.X) > 1e-4 then halfX / math.abs(direction.X) else math.huge,
if math.abs(direction.Y) > 1e-4 then halfY / math.abs(direction.Y) else math.huge
)
local at = centre + direction * scale
chevron.Visible = true
chevron.Position = UDim2.fromOffset(at.X, at.Y)
chevronArrow.Rotation = math.deg(math.atan2(direction.Y, direction.X)) + 90
chevronLabel.Text = `{math.floor(distance)}m`
end
--------------------------------------------------------------------------------
function Waypoint.start()
folder = Create("Folder", { Name = "Waypoint", Parent = Workspace })
--[[
The beam.
A tall, thin, unlit neon column. Deliberately not a particle effect —
it has to be visible through fog, at any time of day, from the far side
of a town, and a solid emissive part is the only thing that reliably is.
]]
beam = Create("Part", {
Name = "Beam",
Anchored = true,
CanCollide = false,
CanQuery = false,
CanTouch = false,
Size = Vector3.new(1.6, 48, 1.6),
Material = Enum.Material.Neon,
Transparency = 0.55,
Color = Theme.Color.Unique,
})
marker = Create("BillboardGui", {
Name = "Marker",
Size = UDim2.fromOffset(220, 62),
StudsOffsetWorldSpace = Vector3.new(0, 27, 0),
AlwaysOnTop = true,
LightInfluence = 0,
Enabled = false,
Parent = player:WaitForChild("PlayerGui"),
})
markerArrow = Create("TextLabel", {
Name = "Arrow",
Size = UDim2.new(1, 0, 0, 34),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "▼",
TextSize = 34,
TextColor3 = Theme.Color.Unique,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.35,
Parent = marker,
})
markerLabel = Create("TextLabel", {
Name = "Label",
Position = UDim2.fromOffset(0, 34),
Size = UDim2.new(1, 0, 0, 24),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 20,
TextColor3 = Theme.Color.Unique,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.35,
Parent = marker,
})
----------------------------------------------------------------------
-- Screen-edge chevron
----------------------------------------------------------------------
root = Layer.root("HUD", "Waypoint")
chevron = Create("Frame", {
Name = "Chevron",
AnchorPoint = Vector2.new(0.5, 0.5),
Size = UDim2.fromOffset(74, 74),
BackgroundTransparency = 1,
Visible = false,
Parent = root,
})
chevronArrow = Create("TextLabel", {
Name = "Arrow",
Size = UDim2.new(1, 0, 0, 46),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "➤",
TextSize = 40,
TextColor3 = Theme.Color.Unique,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.3,
Parent = chevron,
})
chevronLabel = Create("TextLabel", {
Name = "Distance",
Position = UDim2.fromOffset(0, 46),
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 17,
TextColor3 = Theme.Color.Unique,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.35,
Parent = chevron,
})
RunService.RenderStepped:Connect(function()
camera = Workspace.CurrentCamera
local ok, err = pcall(step)
if not ok then
warn(`[Waypoint] {err}`)
end
end)
end
return Waypoint
]]>
-
Screens
-
AbilityBar
accent flash, you just have to wait
stamina -> amber flash, matching the stamina bar's low colour
empty -> muted flash, nothing is assigned
locked -> no flash; the slot already reads as locked
Cooldowns render on RenderStepped straight from UIState rather than through
observers -- they're a continuous countdown, and firing an observer 60
times a second to move one frame's height would be pure overhead.
]]
local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Create = require(ReplicatedStorage.Shared.Util.Create)
local Motion = require(ReplicatedStorage.Shared.Util.Motion)
local Skills = require(ReplicatedStorage.Shared.Config.Skills)
local Theme = require(ReplicatedStorage.Shared.Config.Theme)
local Trove = require(ReplicatedStorage.Shared.Util.Trove)
local Parry = require(ReplicatedStorage.Shared.Config.Parry)
local Events = require(script.Parent.Parent.Core.Events)
local Layer = require(script.Parent.Parent.Core.Layer)
local UIState = require(script.Parent.Parent.Core.UIState)
local SLOT = 66
local GAP = 10
local BOTTOM_MARGIN = 28
local FAIL_COLORS = {
cooldown = Theme.Color.Accent,
stamina = Theme.Color.StaminaEmpty,
empty = Theme.Color.TextMuted,
}
local AbilityBar = {}
local trove = Trove.new()
--- The parry pip sits apart from the Q/E/R slots on purpose: it is a core
--- skill, not a loadout choice, and it should never look like something you
--- could have swapped out.
local parryPip: Frame? = nil
local root: Frame
local slots: { [number]: Frame } = {}
local function buildSlot(slot, parent: Instance): Frame
local frame = Create("Frame", {
Name = `Slot{slot.index}`,
Size = UDim2.fromOffset(SLOT, SLOT),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.12,
BorderSizePixel = 0,
ClipsDescendants = true,
LayoutOrder = slot.index,
Parent = parent,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
-- Skill initial, standing in for art.
Create("TextLabel", {
Name = "Glyph",
Size = UDim2.fromScale(1, 1),
Position = UDim2.fromOffset(0, -4),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 24,
TextColor3 = Theme.Color.Text,
}),
-- Level requirement, shown only while the slot is locked.
Create("TextLabel", {
Name = "Requirement",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 12,
TextColor3 = Theme.Color.TextDim,
}),
-- Cooldown veil: full height at cast, drains to nothing.
Create("Frame", {
Name = "Cooldown",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.fromScale(0, 1),
Size = UDim2.fromScale(1, 0),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
ZIndex = 3,
}),
Create("TextLabel", {
Name = "Timer",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 18,
TextColor3 = Theme.Color.Text,
ZIndex = 4,
}),
-- Key cap, bottom-left.
Create("TextLabel", {
Name = "Key",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.new(0, 6, 1, -3),
Size = UDim2.fromOffset(16, 15),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = slot.label,
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
ZIndex = 5,
}),
-- Stamina cost, bottom-right.
Create("TextLabel", {
Name = "Cost",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(1, -6, 1, -3),
Size = UDim2.fromOffset(30, 15),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.Stamina,
TextXAlignment = Enum.TextXAlignment.Right,
ZIndex = 5,
}),
})
frame:SetAttribute("SlotIndex", slot.index)
Create("UIStroke", {
Name = "Edge",
Color = Theme.Color.Stroke,
Thickness = 1,
Transparency = 0.35,
Parent = frame,
})
return frame
end
local function syncSlots()
local level = UIState.get("level") or 1
local loadout = UIState.get("loadout") or {}
for index, frame in slots do
local unlocked = Skills.isSlotUnlocked(index, level)
local skill = Skills.find(loadout[index])
local slotConfig = Skills.slot(index)
frame.Requirement.Text = if unlocked then "" else `Lv {slotConfig.levelRequired}`
frame.Key.TextTransparency = if unlocked then 0 else 0.6
if not unlocked then
frame.Glyph.Text = ""
frame.Cost.Text = ""
frame.BackgroundTransparency = 0.55
frame.Edge.Transparency = 0.7
elseif skill then
frame.Glyph.Text = string.sub(skill.name, 1, 1)
frame.Glyph.TextColor3 = Theme.Color.Text
frame.Cost.Text = if (skill.staminaCost or 0) > 0 then tostring(skill.staminaCost) else ""
frame.BackgroundTransparency = 0.12
frame.Edge.Transparency = 0.35
frame.Edge.Color = Theme.Color.Stroke
else
frame.Glyph.Text = ""
frame.Cost.Text = ""
frame.BackgroundTransparency = 0.45
frame.Edge.Transparency = 0.6
frame.Edge.Color = Theme.Color.Stroke
end
end
end
local function flash(slotIndex: number, reason: string)
local frame = slots[slotIndex]
local color = FAIL_COLORS[reason]
if not frame or not color then
return
end
frame.Edge.Color = color
frame.Edge.Transparency = 0
Motion.to(frame.Edge, Theme.Time.Slow, { Transparency = 0.35 })
task.delay(Theme.Time.Slow, function()
if frame.Parent then
frame.Edge.Color = Theme.Color.Stroke
end
end)
end
local function pop(slotIndex: number)
local frame = slots[slotIndex]
if not frame then
return
end
frame.Glyph.TextSize = 30
Motion.to(frame.Glyph, Theme.Time.Base, { TextSize = 24 })
end
function AbilityBar.start()
root = Layer.root("HUD", "AbilityBar")
trove:add(root)
local strip = Create("Frame", {
Name = "Strip",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -BOTTOM_MARGIN),
Size = UDim2.fromOffset(SLOT * #Skills.Slots + GAP * (#Skills.Slots - 1), SLOT),
BackgroundTransparency = 1,
Parent = root,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
HorizontalAlignment = Enum.HorizontalAlignment.Center,
Padding = UDim.new(0, GAP),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for _, slot in Skills.Slots do
slots[slot.index] = buildSlot(slot, strip)
end
parryPip = Create("Frame", {
Name = "Parry",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(0.5, -(SLOT * #Skills.Slots + GAP * #Skills.Slots) / 2 - 14, 1, -BOTTOM_MARGIN),
Size = UDim2.fromOffset(SLOT, SLOT),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.12,
BorderSizePixel = 0,
ClipsDescendants = true,
Parent = root,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Name = "Edge", Color = Theme.Color.Unique, Thickness = 1, Transparency = 0.4 }),
Create("TextLabel", {
Name = "Glyph",
Size = UDim2.fromScale(1, 1),
Position = UDim2.fromOffset(0, -4),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "⟠",
TextSize = 26,
TextColor3 = Theme.Color.Unique,
}),
Create("Frame", {
Name = "Cooldown",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.fromScale(0, 1),
Size = UDim2.fromScale(1, 0),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
ZIndex = 3,
}),
Create("TextLabel", {
Name = "Key",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.new(0, 6, 1, -3),
Size = UDim2.fromOffset(16, 15),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "F",
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
ZIndex = 5,
}),
Create("TextLabel", {
Name = "Rank",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(1, -6, 1, -3),
Size = UDim2.fromOffset(30, 15),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Right,
ZIndex = 5,
}),
})
trove:add(UIState.observeMany({ "loadout", "level" }, syncSlots))
trove:add(UIState.observeMany({ "dead", "phase" }, function()
root.Visible = UIState.get("phase") == "playing" and not UIState.get("dead")
end))
trove:connect(Events.AbilityFailed, function(slotIndex, reason)
flash(slotIndex, reason)
end)
trove:connect(Events.AbilityCast, function(slotIndex)
pop(slotIndex)
end)
-- Cooldown sweep. Reads UIState directly each frame; see the header note.
trove:connect(RunService.RenderStepped, function()
if not root.Visible then
return
end
local cooldowns = UIState.get("cooldowns") or {}
local loadout = UIState.get("loadout") or {}
local now = os.clock()
if parryPip then
local rank = UIState.get("parryRank") or 0
local locked = rank <= 0
parryPip.Rank.Text = if locked then "" else `R{rank}`
parryPip.Glyph.TextTransparency = if locked then 0.65 else 0
parryPip.Edge.Transparency = if locked then 0.8 else 0.4
local tier = Parry.forRank(rank)
local readyAt = UIState.get("parryReadyAt") or 0
local remaining = math.max(readyAt - now, 0)
-- The active window flashes bright; the cooldown drains downward.
if now < (UIState.get("parryWindowUntil") or 0) then
parryPip.Edge.Color = Color3.fromRGB(255, 255, 255)
parryPip.Cooldown.Size = UDim2.fromScale(1, 0)
else
parryPip.Edge.Color = Theme.Color.Unique
parryPip.Cooldown.Size = if tier and remaining > 0
then UDim2.fromScale(1, math.clamp(remaining / tier.cooldown, 0, 1))
else UDim2.fromScale(1, 0)
end
end
for index, frame in slots do
local skill = Skills.find(loadout[index])
local remaining = 0
local total = 0
if skill then
local endsAt = cooldowns[skill.id]
if endsAt then
remaining = math.max(endsAt - now, 0)
total = skill.cooldown or 1
end
end
if remaining > 0 and total > 0 then
frame.Cooldown.Size = UDim2.fromScale(1, math.clamp(remaining / total, 0, 1))
frame.Timer.Text = if remaining >= 10
then tostring(math.ceil(remaining))
else string.format("%.1f", remaining)
elseif frame.Timer.Text ~= "" then
frame.Cooldown.Size = UDim2.fromScale(1, 0)
frame.Timer.Text = ""
end
end
end)
end
function AbilityBar.stop()
trove:clean()
table.clear(slots)
end
return AbilityBar
]]>
-
ArenaHud
0 then `{remaining} left` else "clear"
remainingLabel.TextColor3 = if remaining > 0 then Theme.Color.TextMuted else Theme.Color.Success
for index, pip in pips do
local done = index < wave
local active = index == wave
Motion.to(pip, Theme.Time.Fast, {
BackgroundColor3 = if done
then Theme.Color.Success
elseif active then Theme.Color.Unique
else Theme.Color.Stroke,
BackgroundTransparency = if index <= wave then 0 else 0.55,
Size = if active then UDim2.fromOffset(26, 6) else UDim2.fromOffset(18, 4),
})
pip.Visible = index <= total
end
end
function ArenaHud.start()
root = Layer.root("HUD", "Arena")
root.Visible = false
------------------------------------------------------------------
-- Tracker
------------------------------------------------------------------
tracker = Create("Frame", {
Name = "Tracker",
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, 22),
Size = UDim2.fromOffset(220, 54),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.2,
BorderSizePixel = 0,
Parent = root,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Unique, Thickness = 1, Transparency = 0.55 }),
})
waveLabel = Create("TextLabel", {
Name = "Wave",
Position = UDim2.fromOffset(0, 7),
Size = UDim2.new(1, 0, 0, 17),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.Text,
Parent = tracker,
})
remainingLabel = Create("TextLabel", {
Name = "Remaining",
Position = UDim2.fromOffset(0, 23),
Size = UDim2.new(1, 0, 0, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.TextMuted,
Parent = tracker,
})
pipRow = Create("Frame", {
Name = "Pips",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -8),
Size = UDim2.new(1, -20, 0, 6),
BackgroundTransparency = 1,
Parent = tracker,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
HorizontalAlignment = Enum.HorizontalAlignment.Center,
VerticalAlignment = Enum.VerticalAlignment.Center,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for index = 1, TOTAL_PIPS do
table.insert(
pips,
Create("Frame", {
Name = `Pip{index}`,
Size = UDim2.fromOffset(18, 4),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 0.55,
BorderSizePixel = 0,
LayoutOrder = index,
Parent = pipRow,
Create("UICorner", { CornerRadius = UDim.new(1, 0) }),
})
)
end
------------------------------------------------------------------
-- Banner
------------------------------------------------------------------
banner = Create("Frame", {
Name = "Banner",
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, 132),
Size = UDim2.fromOffset(460, 62),
BackgroundTransparency = 1,
Visible = false,
Parent = root,
})
bannerTitle = Create("TextLabel", {
Name = "Title",
Size = UDim2.new(1, 0, 0, 34),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "",
TextSize = 32,
TextColor3 = Theme.Color.Unique,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.4,
Parent = banner,
})
bannerSub = Create("TextLabel", {
Name = "Sub",
Position = UDim2.fromOffset(0, 34),
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.Text,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.55,
Parent = banner,
})
------------------------------------------------------------------
local lastWave = 0
Network.ArenaState.OnClientEvent:Connect(function(payload)
if not payload then
root.Visible = false
lastWave = 0
return
end
root.Visible = true
setWave(payload.wave, payload.totalWaves or TOTAL_PIPS, payload.remaining or 0)
if payload.banner then
showBanner(payload.banner, payload.sub)
-- Only sting on an actual wave change, not on every enemy killed.
if payload.wave ~= lastWave then
lastWave = payload.wave
Audio.play("unique")
end
end
end)
end
return ArenaHud
]]>
-
BootSequence
crosshair sweeps open across the screen
-> perspective grid resolves underneath
-> rings pulse outward from centre
-> neural link sync bar fills
-> title condenses out of letterspacing
-> white flash, dissolve
The title's reveal is a letterspacing collapse: the text starts spread
wide and the gaps close as it fades up. TextLabels can't animate tracking,
so the string is rebuilt each frame via Motion.drive. It's cheap (one
short label) and it's the moment the whole sequence is built around.
Call BootSequence.play() and await the returned signal, or pass onDone.
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Create = require(ReplicatedStorage.Shared.Util.Create)
local Motion = require(ReplicatedStorage.Shared.Util.Motion)
local Theme = require(ReplicatedStorage.Shared.Config.Theme)
local Layer = require(script.Parent.Parent.Core.Layer)
local TITLE = "SHANGRI-LA FRONTIER"
local MAX_TRACKING = 5 -- spaces between characters at the start of the collapse
local BootSequence = {}
local root: Frame
--- Rebuilds `text` with `gaps` spaces between each character.
local function tracked(text: string, gaps: number): string
local spacer = string.rep(" ", math.max(math.floor(gaps), 0))
return table.concat(string.split(text, ""), spacer)
end
local function buildGrid(parent: Instance)
local grid = Create("Frame", {
Name = "Grid",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
Parent = parent,
})
for index = 1, 15 do
Create("Frame", {
Name = `V{index}`,
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.fromScale(index / 16, 0),
Size = UDim2.new(0, 1, 1, 0),
BackgroundColor3 = Theme.Color.Accent,
BackgroundTransparency = 1,
BorderSizePixel = 0,
Parent = grid,
})
end
for index = 1, 8 do
Create("Frame", {
Name = `H{index}`,
AnchorPoint = Vector2.new(0, 0.5),
Position = UDim2.fromScale(0, index / 9),
Size = UDim2.new(1, 0, 0, 1),
BackgroundColor3 = Theme.Color.Accent,
BackgroundTransparency = 1,
BorderSizePixel = 0,
Parent = grid,
})
end
return grid
end
--[[
Runs the dive. Pass `onDone` to be told when it has finished.
THE TOKEN IS NOT OPTIONAL. The sequence is a straight-line coroutine holding
direct references to the parts it built, and its last act is to hide the
layer and call `onDone`. A second `play()` — the admin replay command, a
double-fired boot — used to leave the first one running: it would reach
`root:ClearAllChildren()` and destroy the *new* sequence's elements
mid-animation, then fire `onDone` a second time and shove the player back to
the title screen from wherever they had already got to, which on a slow
machine could be halfway through character creation.
Now every run takes a token, and any run that is no longer the current one
stops at its next beat and touches nothing.
]]
local runToken = 0
--- Returns a signal-ish: pass onDone, or ignore it and rely on timing.
function BootSequence.play(onDone: (() -> ())?)
if not root then
return
end
runToken += 1
local token = runToken
--- True while this run is still the one that should be drawing.
local function current(): boolean
return token == runToken
end
root.Visible = true
root:ClearAllChildren()
local scrim = Create("Frame", {
Name = "Scrim",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Void,
BorderSizePixel = 0,
Parent = root,
})
local grid = buildGrid(scrim)
-- Centre crosshair
local hLine = Create("Frame", {
Name = "HLine",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(0, 1),
BackgroundColor3 = Theme.Color.Accent,
BorderSizePixel = 0,
Parent = scrim,
})
local vLine = Create("Frame", {
Name = "VLine",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(1, 0),
BackgroundColor3 = Theme.Color.Accent,
BackgroundTransparency = 0.5,
BorderSizePixel = 0,
Parent = scrim,
})
local titleLabel = Create("TextLabel", {
Name = "Title",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.46),
Size = UDim2.fromScale(0.9, 0.12),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "",
TextSize = 46,
TextColor3 = Theme.Color.Text,
TextTransparency = 1,
Parent = scrim,
})
local syncLabel = Create("TextLabel", {
Name = "Sync",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.58),
Size = UDim2.fromScale(0.6, 0.04),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = tracked("ESTABLISHING NEURAL LINK", 1),
TextSize = 13,
TextColor3 = Theme.Color.AccentDim,
TextTransparency = 1,
Parent = scrim,
})
local track = Create("Frame", {
Name = "SyncTrack",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.63),
Size = UDim2.fromOffset(360, 2),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 1,
BorderSizePixel = 0,
Parent = scrim,
})
local fill = Create("Frame", {
Name = "SyncFill",
Size = UDim2.fromScale(0, 1),
BackgroundColor3 = Theme.Color.Accent,
BorderSizePixel = 0,
Parent = track,
})
local flash = Create("Frame", {
Name = "Flash",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Color3.new(1, 1, 1),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ZIndex = 20,
Parent = scrim,
})
task.spawn(function()
-- 1. Crosshair opens.
task.wait(0.35)
if not current() then
return
end
Motion.to(hLine, 0.7, { Size = UDim2.fromScale(1, 0) }, Theme.Ease.Enter)
task.wait(0.18)
Motion.to(vLine, 0.7, { Size = UDim2.new(0, 1, 1, 0) }, Theme.Ease.Enter)
-- 2. Grid resolves faintly underneath.
task.wait(0.25)
if not current() then
return
end
for _, line in grid:GetChildren() do
Motion.to(line, 0.9, { BackgroundTransparency = 0.93 }, Theme.Ease.Standard, math.random() * 0.35)
end
-- 3. Rings pulse outward.
task.wait(0.15)
for index = 1, 4 do
task.delay((index - 1) * 0.16, function()
if not current() or not root.Visible then
return
end
local ring = Create("Frame", {
Name = `Ring{index}`,
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(0, 0),
BackgroundTransparency = 1,
Parent = scrim,
Create("UICorner", { CornerRadius = UDim.new(1, 0) }),
Create("UIStroke", { Color = Theme.Color.Accent, Thickness = 1, Transparency = 0.25 }),
})
Motion.to(ring, 1.5, { Size = UDim2.fromOffset(920, 920) }, Theme.Ease.Exit)
Motion.to(ring.UIStroke, 1.5, { Transparency = 1 }, Enum.EasingStyle.Quad)
task.delay(1.6, function()
ring:Destroy()
end)
end)
end
-- 4. Sync bar fills.
task.wait(0.3)
if not current() then
return
end
Motion.to(syncLabel, 0.4, { TextTransparency = 0 })
Motion.to(track, 0.4, { BackgroundTransparency = 0.6 })
Motion.to(fill, 1.5, { Size = UDim2.fromScale(1, 1) }, Enum.EasingStyle.Quad)
task.wait(1.6)
if not current() then
return
end
syncLabel.Text = tracked("LINK ESTABLISHED", 1)
syncLabel.TextColor3 = Theme.Color.Accent
-- 5. Title condenses out of letterspacing.
task.wait(0.25)
if not current() then
return
end
titleLabel.TextTransparency = 1
Motion.to(titleLabel, 0.9, { TextTransparency = 0 }, Theme.Ease.Standard)
Motion.drive(1.0, function(alpha)
if not current() then
return
end
-- Ease the tracking so most of the collapse happens early and it
-- settles gently, matching the fade.
local eased = 1 - (1 - alpha) ^ 3
titleLabel.Text = tracked(TITLE, (1 - eased) * MAX_TRACKING)
end, function()
titleLabel.Text = TITLE
end)
-- Crosshair retreats as the title takes over.
Motion.to(hLine, 0.8, { BackgroundTransparency = 1 })
Motion.to(vLine, 0.8, { BackgroundTransparency = 1 })
Motion.to(syncLabel, 0.6, { TextTransparency = 0.4 }, Theme.Ease.Standard, 0.5)
-- 6. Flash and dissolve.
task.wait(1.5)
if not current() then
return
end
Motion.to(flash, 0.12, { BackgroundTransparency = 0.15 }, Enum.EasingStyle.Quad)
task.wait(0.14)
Motion.to(flash, 0.5, { BackgroundTransparency = 1 }, Enum.EasingStyle.Quad)
Motion.to(scrim, 0.5, { BackgroundTransparency = 1 })
Motion.to(titleLabel, 0.35, { TextTransparency = 1 })
Motion.to(syncLabel, 0.35, { TextTransparency = 1 })
for _, line in grid:GetChildren() do
Motion.to(line, 0.35, { BackgroundTransparency = 1 })
end
task.wait(0.55)
if not current() then
return
end
root.Visible = false
root:ClearAllChildren()
if onDone then
onDone()
end
end)
end
function BootSequence.start()
root = Layer.root("Boot", "BootSequence")
root.Visible = false
end
return BootSequence
]]>
-
BossBar
current
local pip = Create("Frame", {
Name = `Pip{index}`,
Size = UDim2.fromOffset(26, 3),
BackgroundColor3 = if spent then Theme.Color.TextDim else color,
BackgroundTransparency = if spent then 0.4 else 0,
BorderSizePixel = 0,
LayoutOrder = index,
Parent = pipRow,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
table.insert(pips, pip)
end
end
local function show()
if visible then
return
end
visible = true
container.Visible = true
container.Position = UDim2.new(0.5, 0, 0, TOP_MARGIN - 18)
Motion.to(container, Theme.Time.Slow, {
Position = UDim2.new(0.5, 0, 0, TOP_MARGIN),
}, Theme.Ease.Enter)
for _, descendant in container:GetDescendants() do
if descendant:IsA("TextLabel") then
descendant.TextTransparency = 1
Motion.to(descendant, Theme.Time.Slow, { TextTransparency = 0 })
end
end
end
local function hide()
if not visible then
return
end
visible = false
local tween = Motion.to(container, Theme.Time.Base, {
Position = UDim2.new(0.5, 0, 0, TOP_MARGIN - 14),
}, Theme.Ease.Exit)
for _, descendant in container:GetDescendants() do
if descendant:IsA("TextLabel") then
Motion.to(descendant, Theme.Time.Base, { TextTransparency = 1 })
end
end
tween.Completed:Once(function()
if not visible then
container.Visible = false
end
end)
end
function BossBar.start()
local root = Layer.root("HUD", "BossBar")
trove:add(root)
container = Create("Frame", {
Name = "Container",
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, TOP_MARGIN),
Size = UDim2.fromOffset(WIDTH, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
Visible = false,
Parent = root,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
HorizontalAlignment = Enum.HorizontalAlignment.Center,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
titleLabel = Create("TextLabel", {
Name = "Title",
Size = UDim2.new(1, 0, 0, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.4,
LayoutOrder = 1,
Parent = container,
})
nameLabel = Create("TextLabel", {
Name = "BossName",
Size = UDim2.new(1, 0, 0, 30),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 25,
TextColor3 = Theme.Color.Text,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.3,
LayoutOrder = 2,
Parent = container,
})
pipRow = Create("Frame", {
Name = "Phases",
Size = UDim2.new(1, 0, 0, 6),
BackgroundTransparency = 1,
LayoutOrder = 3,
Parent = container,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
HorizontalAlignment = Enum.HorizontalAlignment.Center,
VerticalAlignment = Enum.VerticalAlignment.Center,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
healthBar = Bar.new({
Parent = container,
Size = UDim2.fromOffset(WIDTH, 18),
Color = Theme.Color.Health,
ChipColor = Theme.Color.HealthChip,
Radius = Theme.Radius.sm,
LayoutOrder = 4,
})
trove:add(healthBar)
trove:add(UIState.observe("boss", function(boss)
if not boss then
hide()
return
end
local accent = if boss.unique then Theme.Color.Unique else Theme.Color.Text
nameLabel.Text = string.upper(boss.name or "UNKNOWN")
nameLabel.TextColor3 = accent
titleLabel.Text = if boss.title then string.upper(boss.title) else ""
titleLabel.Visible = boss.title ~= nil
titleLabel.TextColor3 = if boss.unique then Theme.Color.Unique else Theme.Color.TextMuted
setPips(boss.maxPhase or 1, boss.phase or 1, accent)
healthBar:setColor(if boss.unique then Theme.Color.Unique else Theme.Color.Health, not visible)
local wasHidden = not visible
show()
healthBar:setValue(boss.health or 0, boss.maxHealth or 1, wasHidden)
end))
end
function BossBar.stop()
trove:clean()
table.clear(pips)
visible = false
end
return BossBar
]]>
-
CharacterCreate
()
local shown = false
--- Latched by Begin, so the character can only ever be submitted once.
local begun = false
--------------------------------------------------------------------------------
local function validateName(text: string): (boolean, string?)
if #text == 0 then
return false, "Required"
end
if #text < 3 then
return false, "At least 3 characters"
end
if not string.match(text, NAME_PATTERN) then
return false, "Letters, numbers and underscores only"
end
return true, "This is the name other players will see"
end
local function refreshBeginState()
if beginButton then
beginButton:setEnabled(nameField ~= nil and nameField.Valid)
end
end
--------------------------------------------------------------------------------
-- Detail pane
--------------------------------------------------------------------------------
local function meter(parent: Instance, label: string, value: number, order: number)
local row = Create("Frame", {
Name = label,
Size = UDim2.new(1, 0, 0, 26),
BackgroundTransparency = 1,
LayoutOrder = order,
Parent = parent,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 13),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = label,
TextSize = 11,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = row,
})
local track = Create("Frame", {
Position = UDim2.fromOffset(0, 17),
Size = UDim2.new(1, 0, 0, 3),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 0.5,
BorderSizePixel = 0,
Parent = row,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
local fill = Create("Frame", {
Size = UDim2.fromScale(0, 1),
BackgroundColor3 = Theme.Color.Accent,
BorderSizePixel = 0,
Parent = track,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
Motion.to(fill, Theme.Time.Slow, { Size = UDim2.fromScale(value, 1) }, Theme.Ease.Enter)
end
local function renderDetail()
for _, child in detailPane:GetChildren() do
if not child:IsA("UIListLayout") and not child:IsA("UIPadding") then
child:Destroy()
end
end
local style = Characters.findStyle(selectedStyle)
local race = Characters.findRace(selectedRace)
local origin = Characters.findOrigin(selectedOrigin)
local order = 0
local function nextOrder(): number
order += 1
return order
end
-- Origin leads: it is the only choice here that changes the first hour
-- rather than a number.
if origin then
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.upper(origin.name),
TextSize = 16,
TextColor3 = if origin.start == "forest" then Theme.Color.Health else Theme.Color.Accent,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Regular,
Text = origin.description,
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
for _, note in origin.notes do
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = `— {note}`,
TextSize = 11,
TextColor3 = if origin.tutorial then Theme.Color.TextDim else Theme.Color.StaminaEmpty,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
end
Create("Frame", {
Size = UDim2.new(1, 0, 0, 1),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 0.5,
BorderSizePixel = 0,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
end
if style then
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 24),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.upper(style.name),
TextSize = 18,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
local difficultyColor = DIFFICULTY_COLORS[style.difficulty] or Theme.Color.TextMuted
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = string.upper(style.difficulty),
TextSize = 11,
TextColor3 = difficultyColor,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Regular,
Text = style.description,
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
for _, rating in style.ratings do
meter(detailPane, rating.label, rating.value, nextOrder())
end
end
if race then
Create("Frame", {
Size = UDim2.new(1, 0, 0, 1),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 0.5,
BorderSizePixel = 0,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.upper(race.name),
TextSize = 13,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
for _, trait in race.traits do
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = `— {trait}`,
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detailPane,
})
end
end
end
local function selectOrigin(id: string)
selectedOrigin = id
for originId, choice in originChoices do
choice:setSelected(originId == id)
end
renderDetail()
end
local function selectRace(id: string)
selectedRace = id
for raceId, choice in raceChoices do
choice:setSelected(raceId == id)
end
-- Race suggests a skin tone; it stops suggesting once you have chosen one.
if not skinTouched then
selectedLook.skin = Appearance.RaceSkin[id] or Appearance.Skin[1].id
syncSwatches()
end
renderDetail()
end
--- One row of colour swatches. `kind` keys both the palette and the state.
local function swatchRow(parent: Instance, kind: string, palette, order: number)
local row = Create("Frame", {
Name = kind,
Size = UDim2.new(1, 0, 0, 30),
BackgroundTransparency = 1,
LayoutOrder = order,
Parent = parent,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for index, swatch in palette do
local button = Create("TextButton", {
Name = swatch.id,
Size = UDim2.fromOffset(30, 30),
BackgroundColor3 = swatch.color,
AutoButtonColor = false,
BorderSizePixel = 0,
Text = "",
LayoutOrder = index,
Parent = row,
Create("UICorner", { CornerRadius = Theme.Radius.sm }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 2, Transparency = 0.5 }),
})
button.Activated:Connect(function()
if kind == "skin" then
skinTouched = true
end
selectedLook[kind] = swatch.id
-- Selection is a bright ring, never a colour change: the swatch
-- has to keep showing the colour it applies.
for id, other in swatchButtons[kind] do
local stroke = other:FindFirstChildOfClass("UIStroke")
stroke.Color = if id == swatch.id then Theme.Color.Unique else Theme.Color.Stroke
stroke.Transparency = if id == swatch.id then 0 else 0.5
end
end)
swatchButtons[kind][swatch.id] = button
end
return row
end
--- Highlights the swatch matching current state. Used on first build and
--- whenever race changes the skin default.
function syncSwatches()
for kind, buttons in swatchButtons do
for id, button in buttons do
local stroke = button:FindFirstChildOfClass("UIStroke")
local active = selectedLook[kind] == id
stroke.Color = if active then Theme.Color.Unique else Theme.Color.Stroke
stroke.Transparency = if active then 0 else 0.5
end
end
for id, button in buildButtons do
local stroke = button:FindFirstChildOfClass("UIStroke")
local active = selectedLook.build == id
stroke.Color = if active then Theme.Color.Unique else Theme.Color.Stroke
stroke.Transparency = if active then 0 else 0.5
button.TextColor3 = if active then Theme.Color.Text else Theme.Color.TextMuted
end
end
local function selectStyle(id: string)
selectedStyle = id
for styleId, choice in styleChoices do
choice:setSelected(styleId == id)
end
renderDetail()
end
--------------------------------------------------------------------------------
function CharacterCreate.start(onComplete: (character: any) -> ())
root = Layer.root("Frontend", "CharacterCreate")
root.Visible = false
trove:add(root)
Create("Frame", {
Name = "Backdrop",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.06,
BorderSizePixel = 0,
Parent = root,
})
group = Create("Frame", {
Name = "Group",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(1140, 600),
BackgroundTransparency = 1,
Parent = root,
})
-- Header
Create("TextLabel", {
Name = "Heading",
Size = UDim2.new(1, 0, 0, 28),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "CREATE YOUR AVATAR",
TextSize = 22,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = group,
})
Create("TextLabel", {
Name = "Subheading",
Position = UDim2.fromOffset(0, 30),
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "Origin decides where you wake up. Style decides how the game plays.",
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = group,
})
local body = Create("Frame", {
Name = "Body",
Position = UDim2.fromOffset(0, 70),
Size = UDim2.new(1, 0, 1, -140),
BackgroundTransparency = 1,
Parent = group,
})
-- Left: identity
local identity = Create("ScrollingFrame", {
Name = "Identity",
Size = UDim2.new(0, 300, 1, 0),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = body,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 8),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
nameField = TextField.new({
Parent = identity,
Label = "Character name",
Placeholder = "Sunraku",
MaxLength = 16,
LayoutOrder = 1,
Validate = validateName,
OnChanged = function()
refreshBeginState()
end,
})
trove:add(nameField)
----------------------------------------------------------------------
-- Appearance
----------------------------------------------------------------------
local function heading(text: string, order: number)
Create("TextLabel", {
Name = text,
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = text,
TextSize = 11,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = order,
Parent = identity,
})
end
heading("SKIN", 100)
swatchRow(identity, "skin", Appearance.Skin, 101)
heading("HAIR", 102)
swatchRow(identity, "hair", Appearance.Hair, 103)
heading("OUTFIT", 104)
swatchRow(identity, "outfit", Appearance.Outfit, 105)
heading("BUILD", 106)
local buildRow = Create("Frame", {
Name = "Build",
Size = UDim2.new(1, 0, 0, 32),
BackgroundTransparency = 1,
LayoutOrder = 107,
Parent = identity,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for index, build in Appearance.Build do
local button = Create("TextButton", {
Name = build.id,
Size = UDim2.fromOffset(94, 32),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.35,
AutoButtonColor = false,
BorderSizePixel = 0,
FontFace = Theme.Font.SemiBold,
Text = build.name,
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
LayoutOrder = index,
Parent = buildRow,
Create("UICorner", { CornerRadius = Theme.Radius.sm }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 2, Transparency = 0.5 }),
})
button.Activated:Connect(function()
selectedLook.build = build.id
syncSwatches()
end)
buildButtons[build.id] = button
end
-- Race has already been defaulted by now; paint the initial selection.
selectedLook.skin = selectedLook.skin or Appearance.RaceSkin[selectedRace] or Appearance.Skin[1].id
syncSwatches()
Create("TextLabel", {
Name = "OriginHeading",
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "ORIGIN",
TextSize = 11,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = 2,
Parent = identity,
})
for index, origin in Characters.Origins do
local choice = Choice.new({
Parent = identity,
Variant = "row",
Title = origin.name,
Subtitle = origin.tagline,
AccentColor = if origin.start == "forest" then Theme.Color.Health else Theme.Color.Accent,
LayoutOrder = 2 + index,
OnSelect = function()
selectOrigin(origin.id)
end,
})
originChoices[origin.id] = choice
trove:add(choice)
end
Create("TextLabel", {
Name = "RaceHeading",
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "RACE",
TextSize = 11,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = 20,
Parent = identity,
})
for index, race in Characters.Races do
local choice = Choice.new({
Parent = identity,
Variant = "row",
Title = race.name,
Subtitle = race.tagline,
LayoutOrder = 20 + index,
OnSelect = function()
selectRace(race.id)
end,
})
raceChoices[race.id] = choice
trove:add(choice)
end
-- Middle: styles
local styleColumn = Create("Frame", {
Name = "Styles",
Position = UDim2.fromOffset(320, 0),
Size = UDim2.new(0, 490, 1, 0),
BackgroundTransparency = 1,
Parent = body,
})
Create("TextLabel", {
Name = "StyleHeading",
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "COMBAT STYLE",
TextSize = 11,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = styleColumn,
})
local styleGrid = Create("Frame", {
Name = "Grid",
Position = UDim2.fromOffset(0, 24),
Size = UDim2.new(1, 0, 1, -24),
BackgroundTransparency = 1,
Parent = styleColumn,
Create("UIGridLayout", {
CellSize = UDim2.fromOffset(152, 106),
CellPadding = UDim2.fromOffset(10, 10),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for index, style in Characters.Styles do
local choice = Choice.new({
Parent = styleGrid,
Variant = "tile",
Title = style.name,
Subtitle = style.tagline,
Glyph = style.glyph,
LayoutOrder = index,
OnSelect = function()
selectStyle(style.id)
end,
})
styleChoices[style.id] = choice
trove:add(choice)
end
-- Right: detail
local detailFrame = Create("Frame", {
Name = "Detail",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.fromScale(1, 0),
Size = UDim2.new(0, 296, 1, 0),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.2,
BorderSizePixel = 0,
Parent = body,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.5 }),
})
detailPane = Create("ScrollingFrame", {
Name = "DetailContent",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 2,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = detailFrame,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 7),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
Create("UIPadding", {
PaddingTop = UDim.new(0, 16),
PaddingLeft = UDim.new(0, 16),
PaddingRight = UDim.new(0, 16),
PaddingBottom = UDim.new(0, 16),
}),
})
-- Footer
beginButton = Button.new({
Parent = group,
Text = "Begin",
Variant = "primary",
Size = UDim2.fromOffset(240, 50),
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.fromScale(1, 1),
OnClick = function()
if not nameField.Valid then
return
end
--[[
Debounced, and this one matters most in the whole front-end.
`onComplete` fires `CharacterChosen` and `OriginChosen` at the
server, which builds an avatar model, welds it to the character
and routes the spawn. A second click before the hide tween
finishes did all of that twice — two avatar models welded to one
character, and the spawn routed twice — which is exactly the
kind of thing that looks like the game is broken from the very
first second of play.
]]
if begun then
return
end
begun = true
onComplete({
name = nameField:getText(),
origin = selectedOrigin,
race = selectedRace,
style = selectedStyle,
appearance = {
skin = selectedLook.skin,
hair = selectedLook.hair,
outfit = selectedLook.outfit,
build = selectedLook.build,
},
})
end,
})
trove:add(beginButton)
Create("TextLabel", {
Name = "Footnote",
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.fromScale(0, 1),
Size = UDim2.fromOffset(600, 40),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "Style can be respecced later. Race cannot.",
TextSize = 12,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
TextYAlignment = Enum.TextYAlignment.Bottom,
Parent = group,
})
selectOrigin(selectedOrigin)
selectRace(selectedRace)
selectStyle(selectedStyle)
refreshBeginState()
end
function CharacterCreate.show()
if shown then
return
end
shown = true
-- Re-armed on every entry, so the admin replay can create again.
begun = false
root.Visible = true
group.Position = UDim2.fromScale(0.5, 0.52)
Motion.to(group, Theme.Time.Deliberate, { Position = UDim2.fromScale(0.5, 0.5) }, Theme.Ease.Enter)
task.delay(0.35, function()
if shown and nameField then
nameField:focus()
end
end)
end
function CharacterCreate.hide()
if not shown then
return
end
shown = false
local tween = Motion.to(group, Theme.Time.Slow, { Position = UDim2.fromScale(0.5, 0.47) }, Theme.Ease.Exit)
tween.Completed:Once(function()
if not shown then
root.Visible = false
end
end)
end
function CharacterCreate.stop()
trove:clean()
table.clear(originChoices)
table.clear(raceChoices)
table.clear(styleChoices)
shown = false
end
return CharacterCreate
]]>
-
Controls
= total - 1 and not collapsed then
collapsed = true
task.delay(3, function()
if collapsed then
Motion.to(panel, Theme.Time.Slow, { BackgroundTransparency = 1 })
for _, r in rows do
Motion.to(r.key, Theme.Time.Slow, { TextTransparency = 1, BackgroundTransparency = 1 })
Motion.to(r.label, Theme.Time.Slow, { TextTransparency = 1 })
end
end
end)
end
end
function Controls.setVisible(state: boolean)
visible = state
collapsed = false
root.Visible = state
if state then
panel.BackgroundTransparency = 0.15
for key, row in rows do
local learned = used[key]
row.key.TextTransparency = if learned then 0.55 else 0
row.key.BackgroundTransparency = if learned then 0.85 else 0.25
row.label.TextTransparency = if learned then 0.6 else 0.15
end
-- Rows arrive in order rather than the whole block landing at once.
-- This panel is toggled often enough that a hard cut is noticeable, and
-- a sequence reads as a list being offered rather than dumped.
Motion.stagger(Motion.rows(panel))
end
end
--------------------------------------------------------------------------------
function Controls.start()
root = Layer.root("HUD", "Controls")
panel = Create("Frame", {
Name = "Panel",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(1, -26, 1, -26),
Size = UDim2.fromOffset(216, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.15,
BorderSizePixel = 0,
Parent = root,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.35 }),
Create("UIPadding", {
PaddingLeft = UDim.new(0, 12),
PaddingRight = UDim.new(0, 12),
PaddingTop = UDim.new(0, 10),
PaddingBottom = UDim.new(0, 10),
}),
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 5),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
Create("TextLabel", {
Name = "Heading",
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "CONTROLS",
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = 0,
Parent = panel,
})
for index, action in ACTIONS do
local holder = Create("Frame", {
Name = action.id,
Size = UDim2.new(1, 0, 0, 22),
BackgroundTransparency = 1,
LayoutOrder = index,
Parent = panel,
})
-- The key gets a chip; the action gets plain text. A player scanning
-- for "how do I block" is looking for the word, then the chip beside it.
local keyLabel = Create("TextLabel", {
Name = "Key",
Size = UDim2.fromOffset(74, 22),
BackgroundColor3 = if action.accent then Theme.Color.AccentDim else Theme.Color.PanelRaised,
BackgroundTransparency = 0.25,
BorderSizePixel = 0,
FontFace = Theme.Font.Bold,
Text = Bindings.glyph(action.id, gamepad),
TextSize = 13,
TextColor3 = if action.accent then Theme.Color.Accent else Theme.Color.Text,
Parent = holder,
Create("UICorner", { CornerRadius = Theme.Radius.sm }),
})
local textLabel = Create("TextLabel", {
Name = "Label",
Position = UDim2.fromOffset(82, 0),
Size = UDim2.new(1, -82, 1, 0),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = action.text,
TextSize = 14,
TextColor3 = Theme.Color.Text,
TextTransparency = 0.15,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = holder,
})
rows[action.id] = { holder = holder, key = keyLabel, label = textLabel }
end
----------------------------------------------------------------------
UserInputService.InputBegan:Connect(function(input, processed)
if Bindings.matches("controls", input) and not processed then
Controls.setVisible(not visible)
return
end
if processed or not visible then
return
end
-- One matcher for both devices, so learning a control on a pad dims the
-- same row that learning it on a keyboard would.
for _, action in ACTIONS do
if Bindings.matches(action.id, input) then
dim(action)
end
end
end)
----------------------------------------------------------------------
--[[
Repaint the chips when the device changes.
Debounced through a stored flag rather than repainting on every input,
because `LastInputTypeChanged` also fires for mouse movement and this
would otherwise rewrite ten TextLabels several times a second.
]]
UserInputService.LastInputTypeChanged:Connect(function(inputType)
local isPad = inputType.Name:sub(1, 7) == "Gamepad"
local isKeyboardOrMouse = inputType == Enum.UserInputType.Keyboard
or inputType == Enum.UserInputType.MouseButton1
or inputType == Enum.UserInputType.MouseButton2
if isPad == gamepad or not (isPad or isKeyboardOrMouse) then
return
end
gamepad = isPad
for _, action in ACTIONS do
local row = rows[action.id]
if row then
row.key.Text = Bindings.glyph(action.id, gamepad)
end
end
end)
-- Hidden while a menu or the front-end owns the screen.
UIState.observe("phase", function(phase)
root.Visible = visible and phase == "playing"
end)
UIState.observe("menuOpen", function(open)
root.Visible = visible and not open and UIState.get("phase") == "playing"
end)
end
return Controls
]]>
-
Craft
= need.need
Create("TextLabel", {
Name = need.id,
Size = UDim2.fromOffset(0, 18),
AutomaticSize = Enum.AutomaticSize.X,
BackgroundColor3 = if enough then Theme.Color.Success else Theme.Color.Danger,
BackgroundTransparency = 0.82,
BorderSizePixel = 0,
FontFace = Theme.Font.Medium,
Text = ` {need.name} {need.have}/{need.need} `,
TextSize = 11,
TextColor3 = if enough then Theme.Color.Success else Theme.Color.Danger,
LayoutOrder = index,
Parent = strip,
Create("UICorner", { CornerRadius = Theme.Radius.sm }),
})
end
row.MouseEnter:Connect(function()
if recipe.ready then
Audio.play("uiHover")
end
row.BackgroundTransparency = if locked then 0.72 else 0.18
end)
row.MouseLeave:Connect(function()
row.BackgroundTransparency = if locked then 0.72 else 0.38
end)
row.Activated:Connect(function()
if recipe.ready then
Network.Interact:FireServer(npcId, "make", recipe.id)
else
Audio.play("uiClose")
end
end)
end
local function render(payload)
current = payload
goldLabel.Text = `{payload.gold} G`
clear()
-- Craftable first, then locked. The list is a to-do list, so what you can
-- act on now belongs at the top.
local order = 0
for _, pass in { true, false } do
for _, recipe in payload.recipes do
if recipe.ready == pass then
order += 1
recipeRow(recipe, order, payload.npcId)
end
end
end
list.CanvasSize = UDim2.fromOffset(0, list.UIListLayout.AbsoluteContentSize.Y + 10)
end
function Craft.close()
if not Craft.isOpen then
return
end
Craft.isOpen = false
panel:close()
if current then
Network.Interact:FireServer(current.npcId, "close")
end
current = nil
end
function Craft.start()
local root = Layer.root("Menu", "Craft")
panel = Panel.new({
Parent = root,
Size = UDim2.fromOffset(660, 500),
Title = "Bench",
Subtitle = "",
Scrim = true,
AccentColor = Theme.Color.Unique,
OnClose = function()
Craft.close()
end,
})
goldLabel = Create("TextLabel", {
Name = "Gold",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.new(1, -54, 0, Theme.Space.lg),
Size = UDim2.fromOffset(130, 24),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "0 G",
TextSize = 18,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Right,
ZIndex = 4,
Parent = panel.Window,
})
list = Create("ScrollingFrame", {
Name = "Recipes",
Position = UDim2.fromOffset(Theme.Space.lg, 0),
Size = UDim2.new(1, -Theme.Space.lg * 2, 1, -Theme.Space.lg),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
Parent = panel.Content,
Create("UIListLayout", {
Padding = UDim.new(0, 7),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
Network.Craft.OnClientEvent:Connect(function(payload)
if not payload then
if Craft.isOpen then
Craft.isOpen = false
current = nil
panel:close()
end
return
end
panel:setTitle(payload.name)
panel:setSubtitle(payload.greeting or "")
render(payload)
if not Craft.isOpen then
Craft.isOpen = true
panel:open()
end
end)
end
return Craft
]]>
-
DeathScreen
= key and key >= bestKey then
best, bestKey = text, key
end
end
return best
end
local function setShown(visible: boolean)
if shown == visible then
return
end
shown = visible
if visible then
local deaths = (UIState.get("deaths") or 0) + 1
UIState.set("deaths", deaths)
countLabel.Text = `DEATH {deaths}`
flavourLabel.Text = flavourFor(deaths)
root.Visible = true
scrim.BackgroundTransparency = 1
headline.TextTransparency = 1
headline.TextSize = 76
Motion.to(scrim, Theme.Time.Deliberate, { BackgroundTransparency = 0.25 })
Motion.to(headline, 1.1, { TextTransparency = 0, TextSize = 64 }, Theme.Ease.Exit)
for _, label in { countLabel, flavourLabel } do
label.TextTransparency = 1
Motion.to(label, Theme.Time.Deliberate, { TextTransparency = 0 }, Theme.Ease.Standard, 0.5)
end
respawnButton.Root.Visible = false
task.delay(1.1, function()
if shown then
respawnButton.Root.Visible = true
respawnButton.Root.BackgroundTransparency = 1
Motion.to(respawnButton.Root, Theme.Time.Slow, { BackgroundTransparency = 0 })
end
end)
else
local tween = Motion.to(scrim, Theme.Time.Slow, { BackgroundTransparency = 1 })
Motion.to(headline, Theme.Time.Base, { TextTransparency = 1 })
Motion.to(countLabel, Theme.Time.Base, { TextTransparency = 1 })
Motion.to(flavourLabel, Theme.Time.Base, { TextTransparency = 1 })
tween.Completed:Once(function()
if not shown then
root.Visible = false
end
end)
end
end
function DeathScreen.start()
root = Layer.root("Fullscreen", "DeathScreen")
root.Visible = false
trove:add(root)
scrim = Create("Frame", {
Name = "Scrim",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 1,
BorderSizePixel = 0,
Parent = root,
})
local column = Create("Frame", {
Name = "Column",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(620, 260),
BackgroundTransparency = 1,
Parent = root,
})
headline = Create("TextLabel", {
Name = "Headline",
Position = UDim2.fromScale(0, 0),
Size = UDim2.new(1, 0, 0, 80),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "YOU DIED",
TextSize = 64,
TextColor3 = Theme.Color.Health,
TextTransparency = 1,
Parent = column,
})
countLabel = Create("TextLabel", {
Name = "Count",
Position = UDim2.fromOffset(0, 90),
Size = UDim2.new(1, 0, 0, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 16,
TextColor3 = Theme.Color.TextMuted,
TextTransparency = 1,
Parent = column,
})
flavourLabel = Create("TextLabel", {
Name = "Flavour",
Position = UDim2.fromOffset(0, 116),
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.TextDim,
TextTransparency = 1,
Parent = column,
})
respawnButton = Button.new({
Parent = column,
Text = "Respawn",
Variant = "primary",
AccentColor = Theme.Color.Accent,
Size = UDim2.fromOffset(220, 46),
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, 172),
OnClick = function()
UIState.patch({
dead = false,
health = UIState.get("maxHealth"),
stamina = UIState.get("maxStamina"),
boss = nil,
})
end,
})
trove:add(respawnButton)
trove:add(UIState.observe("dead", function(dead)
setShown(dead == true)
end))
end
function DeathScreen.stop()
trove:clean()
shown = false
end
return DeathScreen
]]>
-
Dialogue
-
FishingHud
= 1 - Fishing.PerfectBand then Theme.Color.Unique else Theme.Color.TextMuted
card.Visible = true
card.Position = UDim2.new(0.5, 0, 1, -196)
Motion.to(card, Theme.Time.Base, { Position = UDim2.new(0.5, 0, 1, -214) }, Theme.Ease.Enter)
task.delay(3.2, function()
local tween = Motion.to(card, Theme.Time.Base, { Position = UDim2.new(0.5, 0, 1, -196) }, Theme.Ease.Exit)
tween.Completed:Once(function()
card.Visible = false
end)
end)
end
local function stop()
FishingHud.isCasting = false
sweeping = false
bar.Visible = false
setHint("")
end
function FishingHud.start()
root = Layer.root("HUD", "Fishing")
hint = Create("TextLabel", {
Name = "Hint",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -150),
Size = UDim2.fromOffset(420, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 15,
TextColor3 = Theme.Color.TextMuted,
TextStrokeColor3 = Theme.Color.Void,
TextStrokeTransparency = 0.4,
Visible = false,
Parent = root,
})
------------------------------------------------------------------
-- The strike bar
------------------------------------------------------------------
bar = Create("Frame", {
Name = "Bar",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -118),
Size = UDim2.fromOffset(340, 22),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.15,
BorderSizePixel = 0,
Visible = false,
Parent = root,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.3 }),
})
-- The band you are aiming for. Sized from the same constant the server
-- grades against, so what you see is what it scores.
Create("Frame", {
Name = "Band",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.new(Fishing.PerfectBand, 0, 1, -6),
BackgroundColor3 = Theme.Color.Success,
BackgroundTransparency = 0.45,
BorderSizePixel = 0,
Parent = bar,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
--[[
Amber shoulder: "good but not perfect", so the bar isn't hit-or-miss.
0.4 is not a look-nice number. The server grades GOOD at quality >= 0.6,
quality is 1 - |offset|, and offset is 2t-1 across the window — which
works out to t in [0.3, 0.7], a band exactly 0.4 wide. It was 0.55,
which promised a grade over a sixth of the bar that the server would
not actually award. A meter that lies about its own scoring is worse
than no meter.
]]
Create("Frame", {
Name = "Shoulder",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.new(0.4, 0, 1, -6),
BackgroundColor3 = Theme.Color.StaminaEmpty,
BackgroundTransparency = 0.82,
BorderSizePixel = 0,
ZIndex = 0,
Parent = bar,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
marker = Create("Frame", {
Name = "Marker",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0, 0.5),
Size = UDim2.fromOffset(4, 30),
BackgroundColor3 = Theme.Color.Text,
BorderSizePixel = 0,
ZIndex = 3,
Parent = bar,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
------------------------------------------------------------------
-- The catch card
------------------------------------------------------------------
card = Create("Frame", {
Name = "Catch",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -214),
Size = UDim2.fromOffset(300, 52),
BackgroundColor3 = Theme.Color.Panel,
BackgroundTransparency = 0.08,
BorderSizePixel = 0,
Visible = false,
Parent = root,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.25 }),
})
cardName = Create("TextLabel", {
Name = "Name",
Position = UDim2.fromOffset(0, 8),
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 17,
TextColor3 = Theme.Color.Text,
Parent = card,
})
cardGrade = Create("TextLabel", {
Name = "Grade",
Position = UDim2.fromOffset(0, 28),
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
Parent = card,
})
------------------------------------------------------------------
RunService.RenderStepped:Connect(function()
if not sweeping then
return
end
-- Sweeps once across the window, so early reads as left and late as
-- right. Past the end the marker parks; the server has already called it.
local t = math.clamp((os.clock() - biteAt) / Fishing.HookWindow, 0, 1)
marker.Position = UDim2.fromScale(t, 0.5)
end)
Network.Fishing.OnClientEvent:Connect(function(payload)
if payload.state == "cast" then
FishingHud.isCasting = true
bar.Visible = false
setHint("Line's out. Wait for it — G to strike.")
elseif payload.state == "bite" then
biteAt = os.clock()
sweeping = true
bar.Visible = true
marker.Position = UDim2.fromScale(0, 0.5)
setHint("STRIKE", Theme.Color.Unique)
elseif payload.state == "caught" then
stop()
showCard(payload.fish, payload.grade, payload.quality)
elseif payload.state == "missed" then
stop()
setHint("It's gone.", Theme.Color.TextDim)
task.delay(1.6, function()
if not FishingHud.isCasting then
setHint("")
end
end)
elseif payload.state == "early" then
stop()
setHint("Too early — the float went under.", Theme.Color.Danger)
task.delay(1.6, function()
if not FishingHud.isCasting then
setHint("")
end
end)
end
end)
end
return FishingHud
]]>
-
HUD
0
goldLabel.Text = `{gold or 0} G`
end))
statusList = Create("Frame", {
Name = "Statuses",
Size = UDim2.new(1, 0, 0, 24),
AutomaticSize = Enum.AutomaticSize.X,
BackgroundTransparency = 1,
LayoutOrder = 6,
Parent = column,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
Padding = UDim.new(0, 6),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
-- Bindings
trove:add(UIState.observeMany({ "health", "maxHealth" }, function()
healthBar:setValue(UIState.get("health"), UIState.get("maxHealth"))
end))
-- Sprint writes stamina every frame, so this renders instantly rather than
-- tweening: a tween per frame would queue 60 a second and trail the input.
local staminaLow = false
trove:add(UIState.observeMany({ "stamina", "maxStamina" }, function()
local current, max = UIState.get("stamina"), UIState.get("maxStamina")
staminaBar:setValue(current, max, true)
-- Low stamina turns amber: you're about to lose your sprint, and you
-- need to know that faster than you can read a number.
local low = max > 0 and (current / max) < 0.2
if low ~= staminaLow then
staminaLow = low
staminaBar:setColor(if low then Theme.Color.StaminaEmpty else Theme.Color.Stamina)
end
end))
trove:add(UIState.observeMany({ "experience", "experienceToNext" }, function()
xpBar:setValue(UIState.get("experience"), UIState.get("experienceToNext"))
end))
trove:add(UIState.observe("displayName", function(value)
nameLabel.Text = value or ""
end))
trove:add(UIState.observe("level", function(value)
levelLabel.Text = `Lv {value or 1}`
end))
trove:add(UIState.observe("statuses", syncStatuses))
-- Status countdowns tick locally; the server only sends expiry times.
trove:connect(RunService.Heartbeat, function()
local now = os.clock()
local statuses = UIState.get("statuses")
if not statuses then
return
end
for _, status in statuses do
local chip = statusChips[status.id]
if chip and status.expiresAt then
local remaining = math.max(status.expiresAt - now, 0)
chip.Timer.Text = if remaining > 0 then string.format("%.1fs", remaining) else ""
end
end
end)
-- The HUD exists only during gameplay, and the death screen owns the frame
-- while dead.
trove:add(UIState.observeMany({ "dead", "phase" }, function()
root.Visible = UIState.get("phase") == "playing" and not UIState.get("dead")
end))
end
function HUD.stop()
trove:clean()
table.clear(statusChips)
end
return HUD
]]>
-
Menu
-
InventoryTab
0 then
Create("Frame", {
Name = "Divider",
Size = UDim2.new(1, 0, 0, 1),
BackgroundColor3 = Theme.Color.Stroke,
BackgroundTransparency = 0.4,
BorderSizePixel = 0,
LayoutOrder = nextOrder(),
Parent = detail,
})
Create("TextLabel", {
Name = "CurseHeading",
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "CURSE",
TextSize = 12,
TextColor3 = Theme.Color.Cursed,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
for _, drawback in item.drawbacks do
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = `— {drawback}`,
TextSize = 12,
TextColor3 = Theme.Color.Danger,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
end
end
end
--------------------------------------------------------------------------------
local function buildCell(item): TextButton
local rarity = rarityOf(item)
local cell = Create("TextButton", {
Name = item.id,
Size = UDim2.fromOffset(CELL, CELL),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.2,
AutoButtonColor = false,
BorderSizePixel = 0,
Text = "",
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Name = "Rarity", Color = rarity.Color, Thickness = 1, Transparency = 0.35 }),
-- Placeholder glyph until real item art exists.
Create("TextLabel", {
Name = "Glyph",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.sub(item.name, 1, 1),
TextSize = 22,
TextColor3 = rarity.Color,
}),
})
-- Corner tick marks cursed gear even before you read the name.
if item.rarity == "Cursed" then
Create("Frame", {
Name = "CurseMark",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.fromScale(1, 1),
Size = UDim2.fromOffset(8, 8),
BackgroundColor3 = Theme.Color.Cursed,
BorderSizePixel = 0,
Parent = cell,
Create("UICorner", { CornerRadius = Theme.Radius.pill }),
})
end
if item.quantity and item.quantity > 1 then
Create("TextLabel", {
Name = "Quantity",
AnchorPoint = Vector2.new(1, 1),
Position = UDim2.new(1, -4, 1, -2),
Size = UDim2.fromOffset(24, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = tostring(item.quantity),
TextSize = 11,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Right,
Parent = cell,
})
end
cell.MouseEnter:Connect(function()
Motion.to(cell, Theme.Time.Fast, { BackgroundTransparency = 0 })
end)
cell.MouseLeave:Connect(function()
Motion.to(cell, Theme.Time.Fast, { BackgroundTransparency = 0.2 })
end)
cell.Activated:Connect(function()
UIState.set("selectedItem", item.id)
end)
return cell
end
local function syncGrid()
for _, cell in cells do
cell:Destroy()
end
table.clear(cells)
for index, item in UIState.get("inventory") or {} do
local cell = buildCell(item)
cell.LayoutOrder = index
cell.Parent = grid
cells[item.id] = cell
end
end
local function syncSelection()
local selectedId = UIState.get("selectedItem")
for id, cell in cells do
local stroke = cell:FindFirstChild("Rarity")
if stroke then
stroke.Transparency = if id == selectedId then 0 else 0.35
stroke.Thickness = if id == selectedId then 2 else 1
end
end
renderDetail(findItem(selectedId))
end
local function syncEquipment()
local equipment = UIState.get("equipment") or {}
for slotName, frame in slotFrames do
local item = findItem(equipment[slotName])
local rarity = rarityOf(item)
frame.Glyph.Text = if item then string.sub(item.name, 1, 1) else ""
frame.Glyph.TextColor3 = rarity.Color
frame.SlotName.TextColor3 = if item then Theme.Color.TextMuted else Theme.Color.TextDim
frame.Rarity.Color = if item then rarity.Color else Theme.Color.Stroke
frame.Rarity.Transparency = if item then 0.25 else 0.6
end
end
--------------------------------------------------------------------------------
function InventoryTab.build(parent: Frame, trove)
-- Equipment column
local equipColumn = Create("Frame", {
Name = "Equipment",
Size = UDim2.new(0, 170, 1, 0),
BackgroundTransparency = 1,
Parent = parent,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 6),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for index, slotName in EQUIP_SLOTS do
slotFrames[slotName] = Create("Frame", {
Name = slotName,
Size = UDim2.new(1, 0, 0, 44),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
LayoutOrder = index,
Parent = equipColumn,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Name = "Rarity", Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.6 }),
Create("TextLabel", {
Name = "Glyph",
Size = UDim2.fromOffset(44, 44),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 18,
TextColor3 = Theme.Color.TextDim,
}),
Create("TextLabel", {
Name = "SlotName",
Position = UDim2.fromOffset(48, 0),
Size = UDim2.new(1, -52, 1, 0),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = slotName,
TextSize = 12,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
}),
})
end
-- Item grid
grid = Create("ScrollingFrame", {
Name = "Grid",
Position = UDim2.fromOffset(190, 0),
Size = UDim2.new(1, -190 - 280, 1, 0),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = parent,
Create("UIGridLayout", {
CellSize = UDim2.fromOffset(CELL, CELL),
CellPadding = UDim2.fromOffset(8, 8),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
Create("UIPadding", { PaddingRight = UDim.new(0, 10) }),
})
-- Detail pane
local detailFrame = Create("Frame", {
Name = "Detail",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.fromScale(1, 0),
Size = UDim2.new(0, 268, 1, 0),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
Parent = parent,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.5 }),
})
detail = Create("ScrollingFrame", {
Name = "DetailContent",
Size = UDim2.fromScale(1, 1),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 2,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = detailFrame,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 7),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
Create("UIPadding", {
PaddingTop = UDim.new(0, 14),
PaddingLeft = UDim.new(0, 14),
PaddingRight = UDim.new(0, 14),
PaddingBottom = UDim.new(0, 14),
}),
})
trove:add(UIState.observe("inventory", function()
syncGrid()
syncSelection()
syncEquipment()
end))
trove:add(UIState.observe("selectedItem", syncSelection))
trove:add(UIState.observe("equipment", syncEquipment))
end
return InventoryTab
]]>
-
QuestsTab
= quest.objective.count then "ready" else "active"
table.insert(buckets[key], { quest = quest, progress = progress })
elseif not quest.requires or states[quest.requires] == "done" then
-- Unlocked by the chain but not yet taken: worth one line so the
-- next step in a chain isn't invisible.
table.insert(buckets.lead, { quest = quest, progress = 0 })
end
end
local order = 0
for _, group in GROUPS do
local entries = buckets[group.key]
if #entries == 0 then
continue
end
order += 1
Create("Frame", {
Name = `Header{group.key}`,
Size = UDim2.new(1, -10, 0, 24),
BackgroundTransparency = 1,
LayoutOrder = order,
Parent = list,
Create("TextLabel", {
AnchorPoint = Vector2.new(0, 1),
Position = UDim2.new(0, 2, 1, -4),
Size = UDim2.new(1, -4, 0, 14),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = `{group.label} ({#entries})`,
TextSize = 11,
TextColor3 = group.color,
TextXAlignment = Enum.TextXAlignment.Left,
}),
})
for _, entry in entries do
order += 1
card(order, entry.quest, group, entry.progress)
end
end
local active = #buckets.active + #buckets.ready
summary.Text = if active == 0
then "Nothing on. Talk to anyone in Firstia with a gold title."
else `{active} job{if active == 1 then "" else "s"} in hand · {#buckets.done} finished`
list.CanvasSize = UDim2.fromOffset(0, list.UIListLayout.AbsoluteContentSize.Y + 10)
end
function QuestsTab.build(parent: Frame, trove)
summary = Create("TextLabel", {
Name = "Summary",
Position = UDim2.fromOffset(0, 0),
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = parent,
})
list = Create("ScrollingFrame", {
Name = "Quests",
Position = UDim2.fromOffset(0, 26),
Size = UDim2.new(1, 0, 1, -26),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
Parent = parent,
Create("UIListLayout", {
Padding = UDim.new(0, 6),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
trove:add(UIState.observeMany({ "quests", "questProgress" }, sync))
end
return QuestsTab
]]>
-
ScenariosTab
-
SettingsTab
-
SkillsTab
0
then `{skill.staminaCost} stamina · {skill.cooldown or 0}s`
else `{skill.cooldown or 0}s cooldown`
else
card.SkillName.Text = "Empty"
card.SkillName.TextColor3 = Theme.Color.TextDim
card.Hint.Text = "Select a skill to assign"
end
local edge = card:FindFirstChild("Edge")
if edge then
edge.Color = if skill and unlocked then Theme.Color.Accent else Theme.Color.Stroke
edge.Transparency = if not unlocked then 0.75 elseif skill then 0.25 else 0.55
end
end
end
local function buildStrip(parent: Frame)
local strip = Create("Frame", {
Name = "Loadout",
Position = UDim2.fromOffset(0, STRIP_TOP),
Size = UDim2.new(1, 0, 0, STRIP_HEIGHT),
BackgroundTransparency = 1,
Parent = parent,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
Padding = UDim.new(0, 10),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for _, slot in Skills.Slots do
local card = Create("TextButton", {
Name = `Slot{slot.index}`,
Size = UDim2.fromOffset(232, STRIP_HEIGHT),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.4,
AutoButtonColor = false,
BorderSizePixel = 0,
Text = "",
LayoutOrder = slot.index,
Parent = strip,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Name = "Edge", Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.55 }),
Create("TextLabel", {
Name = "Key",
Position = UDim2.fromOffset(14, 0),
Size = UDim2.fromOffset(26, STRIP_HEIGHT),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = slot.label,
TextSize = 20,
TextColor3 = Theme.Color.Accent,
TextXAlignment = Enum.TextXAlignment.Left,
}),
Create("TextLabel", {
Name = "SkillName",
Position = UDim2.fromOffset(48, 13),
Size = UDim2.new(1, -60, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
}),
Create("TextLabel", {
Name = "Hint",
Position = UDim2.fromOffset(48, 31),
Size = UDim2.new(1, -60, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
}),
})
card.MouseEnter:Connect(function()
Motion.to(card, Theme.Time.Fast, { BackgroundTransparency = 0.2 })
end)
card.MouseLeave:Connect(function()
Motion.to(card, Theme.Time.Fast, { BackgroundTransparency = 0.4 })
end)
card.Activated:Connect(function()
Loadout.clear(slot.index)
end)
slotCards[slot.index] = card
end
end
--------------------------------------------------------------------------------
-- Detail pane
--------------------------------------------------------------------------------
local function syncEquipRow()
local skill = Skills.find(UIState.get("selectedSkill"))
local current = Loadout.slotOf(skill and skill.id)
for index, button in equipButtons do
local slotUnlocked = Loadout.isSlotUnlocked(index)
local usable = skill ~= nil and Skills.isSlottable(skill) and isUnlocked(skill.id) and slotUnlocked
local occupied = current == index
button.AutoButtonColor = false
button.BackgroundColor3 = if occupied then Theme.Color.Accent else Theme.Color.PanelRaised
button.BackgroundTransparency = if usable or occupied then 0.1 else 0.6
button.TextColor3 = if occupied
then Theme.Color.TextInverse
elseif usable then Theme.Color.Text
else Theme.Color.TextDim
end
end
local function renderDetail()
for _, child in detail:GetChildren() do
if not child:IsA("UIListLayout") and not child:IsA("UIPadding") then
child:Destroy()
end
end
table.clear(equipButtons)
local skill = lookup(UIState.get("selectedSkill"))
if not skill then
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 40),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "Select a skill",
TextSize = 13,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = detail,
})
unlockButton.Root.Visible = false
return
end
local unlocked = isUnlocked(skill.id)
local order = 0
local function nextOrder(): number
order += 1
return order
end
-- Core skills are ranked, not slotted. Show the whole ladder so the player
-- can see what the next point actually buys before spending it.
if skill.core then
local rank = UIState.get("parryRank") or 0
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 26),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = skill.name,
TextSize = 19,
TextColor3 = if rank > 0 then Theme.Color.Accent else Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = if rank > 0
then `Rank {rank} / {Parry.maxRank()} · key {skill.key}`
else `Locked · key {skill.key}`,
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Regular,
Text = skill.description,
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
for _, tier in Parry.Ranks do
local owned = rank >= tier.rank
local isNext = rank + 1 == tier.rank
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = if isNext then Theme.Font.SemiBold else Theme.Font.Medium,
Text = `{if owned then "✓" else "—"} Rank {tier.rank}: {tier.summary}`,
TextSize = 11,
TextColor3 = if owned
then Theme.Color.Success
elseif isNext then Theme.Color.Text
else Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
end
local cost = Parry.upgradeCost(rank)
unlockButton.Root.Visible = cost ~= nil
if cost then
unlockButton:setEnabled((UIState.get("skillPoints") or 0) >= cost)
unlockButton:setText(if rank == 0 then `Unlock — {cost}` else `Upgrade — {cost}`)
end
return
end
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 26),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = skill.name,
TextSize = 19,
TextColor3 = if unlocked then Theme.Color.Accent else Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
local meta = if skill.passive
then `Tier {skill.tier} · Passive`
else `Tier {skill.tier} · {skill.cooldown or 0}s · {skill.staminaCost or 0} stamina`
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = meta,
TextSize = 12,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.Regular,
Text = skill.description,
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
if not unlocked then
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = `LOCKED — {skill.cost} POINT{if skill.cost == 1 then "" else "S"}`,
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
elseif skill.passive then
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 0),
AutomaticSize = Enum.AutomaticSize.Y,
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "PASSIVE — always active, no slot needed",
TextSize = 11,
TextColor3 = Theme.Color.Success,
TextXAlignment = Enum.TextXAlignment.Left,
TextWrapped = true,
LayoutOrder = nextOrder(),
Parent = detail,
})
else
Create("TextLabel", {
Size = UDim2.new(1, 0, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "ASSIGN TO SLOT",
TextSize = 10,
TextColor3 = Theme.Color.AccentDim,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = nextOrder(),
Parent = detail,
})
local row = Create("Frame", {
Size = UDim2.new(1, 0, 0, 40),
BackgroundTransparency = 1,
LayoutOrder = nextOrder(),
Parent = detail,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Horizontal,
Padding = UDim.new(0, 8),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
for _, slot in Skills.Slots do
local button = Create("TextButton", {
Name = slot.label,
Size = UDim2.fromOffset(72, 40),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.6,
AutoButtonColor = false,
BorderSizePixel = 0,
FontFace = Theme.Font.Bold,
Text = slot.label,
TextSize = 15,
TextColor3 = Theme.Color.TextDim,
LayoutOrder = slot.index,
Parent = row,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
})
button.Activated:Connect(function()
local selected = UIState.get("selectedSkill")
if Loadout.slotOf(selected) == slot.index then
Loadout.clear(slot.index)
else
Loadout.assign(slot.index, selected)
end
end)
equipButtons[slot.index] = button
end
syncEquipRow()
end
unlockButton.Root.Visible = not unlocked
unlockButton:setEnabled((UIState.get("skillPoints") or 0) >= skill.cost)
unlockButton:setText(`Unlock — {skill.cost}`)
end
--------------------------------------------------------------------------------
-- Skill list
--------------------------------------------------------------------------------
local function syncRows()
local selected = UIState.get("selectedSkill")
for id, row in rows do
local skill, isCore = lookup(id)
if not skill then
continue
end
-- Core skills show a rank instead of a cost and a key instead of a slot.
if isCore then
local rank = UIState.get("parryRank") or 0
row.Name1.TextColor3 = if rank > 0 then Theme.Color.Accent else Theme.Color.Text
row.Sub.Text = if rank > 0 then `Rank {rank} / {Parry.maxRank()}` else "Locked"
row.Cost.Text = if rank > 0 then tostring(rank) else "—"
row.Cost.TextColor3 = if rank > 0 then Theme.Color.Unique else Theme.Color.TextMuted
local coreEdge = row:FindFirstChild("Edge")
if coreEdge then
coreEdge.Transparency = if id == selected then 0 else 0.55
coreEdge.Color = if id == selected then Theme.Color.Unique else Theme.Color.Stroke
end
continue
end
local unlocked = isUnlocked(id)
local slotIndex = Loadout.slotOf(id)
row.Name1.TextColor3 = if unlocked then Theme.Color.Accent else Theme.Color.Text
row.Cost.Text = if unlocked then "✓" else tostring(skill.cost)
row.Cost.TextColor3 = if unlocked then Theme.Color.Success else Theme.Color.TextMuted
-- The slot badge is why this list is scannable: at a glance you can
-- see which of your unlocks are actually bound to a key.
if slotIndex then
row.Slot.Text = Skills.slot(slotIndex).label
row.Slot.TextTransparency = 0
else
row.Slot.Text = ""
row.Slot.TextTransparency = 1
end
row.Sub.Text = if skill.passive then "Passive" else `{skill.cooldown or 0}s · {skill.staminaCost or 0} stamina`
local edge = row:FindFirstChild("Edge")
if edge then
edge.Transparency = if id == selected then 0 else 0.55
edge.Color = if id == selected then Theme.Color.Accent else Theme.Color.Stroke
end
end
end
--- One list row. Core skills get the same shape so the list reads as one
--- thing, but they carry a key cap instead of a loadout slot badge.
local function buildRow(skill, isCore: boolean?): TextButton
local row = Create("TextButton", {
Name = skill.id,
Size = UDim2.new(1, -10, 0, 46),
BackgroundColor3 = Theme.Color.PanelRaised,
BackgroundTransparency = 0.4,
AutoButtonColor = false,
BorderSizePixel = 0,
Text = "",
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Name = "Edge", Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.55 }),
Create("TextLabel", {
Name = "Name1",
Position = UDim2.fromOffset(14, 6),
Size = UDim2.new(1, -90, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = skill.name,
TextSize = 14,
TextColor3 = Theme.Color.Text,
TextXAlignment = Enum.TextXAlignment.Left,
TextTruncate = Enum.TextTruncate.AtEnd,
}),
Create("TextLabel", {
Name = "Sub",
Position = UDim2.fromOffset(14, 24),
Size = UDim2.new(1, -90, 0, 16),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "",
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
TextXAlignment = Enum.TextXAlignment.Left,
}),
Create("TextLabel", {
Name = "Slot",
AnchorPoint = Vector2.new(1, 0.5),
Position = UDim2.new(1, -44, 0.5, 0),
Size = UDim2.fromOffset(22, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = if isCore then skill.key else "",
TextSize = 13,
TextColor3 = if isCore then Theme.Color.Unique else Theme.Color.Accent,
TextTransparency = if isCore then 0 else 1,
}),
Create("TextLabel", {
Name = "Cost",
AnchorPoint = Vector2.new(1, 0.5),
Position = UDim2.new(1, -14, 0.5, 0),
Size = UDim2.fromOffset(26, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "",
TextSize = 14,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Right,
}),
})
row.MouseEnter:Connect(function()
Motion.to(row, Theme.Time.Fast, { BackgroundTransparency = 0.2 })
end)
row.MouseLeave:Connect(function()
Motion.to(row, Theme.Time.Fast, { BackgroundTransparency = 0.4 })
end)
row.Activated:Connect(function()
UIState.set("selectedSkill", skill.id)
end)
return row
end
local function rebuildList()
for _, row in rows do
row:Destroy()
end
table.clear(rows)
local character = UIState.get("character")
local available = Skills.forStyle(character and character.style)
local lastTier = nil
local order = 0
-- Core skills sit above the tree: permanent, keybound, and not competing
-- with any build choice.
Create("TextLabel", {
Name = "CoreHeading",
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "CORE",
TextSize = 11,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = 0,
Parent = list,
})
for _, core in Skills.Core do
local row = buildRow(core, true)
row.LayoutOrder = 1
row.Parent = list
rows[core.id] = row
end
for _, skill in available do
order += 1
if skill.tier ~= lastTier then
lastTier = skill.tier
Create("TextLabel", {
Name = `TierHeading{skill.tier}`,
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = `TIER {skill.tier}`,
TextSize = 11,
TextColor3 = Theme.Color.AccentDim,
TextXAlignment = Enum.TextXAlignment.Left,
LayoutOrder = order,
Parent = list,
})
order += 1
end
local row = buildRow(skill)
row.LayoutOrder = order
row.Parent = list
rows[skill.id] = row
end
syncRows()
renderDetail()
end
--------------------------------------------------------------------------------
function SkillsTab.build(parent: Frame, trove)
pointsLabel = Create("TextLabel", {
Name = "Points",
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.SemiBold,
Text = "",
TextSize = 13,
TextColor3 = Theme.Color.Accent,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = parent,
})
buildStrip(parent)
list = Create("ScrollingFrame", {
Name = "List",
Position = UDim2.fromOffset(0, LIST_TOP),
Size = UDim2.new(1, -290, 1, -LIST_TOP),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = parent,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 6),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
local detailFrame = Create("Frame", {
Name = "Detail",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.new(1, 0, 0, LIST_TOP),
Size = UDim2.new(0, 278, 1, -LIST_TOP),
BackgroundColor3 = Theme.Color.Void,
BackgroundTransparency = 0.35,
BorderSizePixel = 0,
Parent = parent,
Create("UICorner", { CornerRadius = Theme.Radius.md }),
Create("UIStroke", { Color = Theme.Color.Stroke, Thickness = 1, Transparency = 0.5 }),
})
detail = Create("ScrollingFrame", {
Name = "DetailContent",
Size = UDim2.new(1, 0, 1, -62),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 2,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
AutomaticCanvasSize = Enum.AutomaticSize.Y,
Parent = detailFrame,
Create("UIListLayout", {
FillDirection = Enum.FillDirection.Vertical,
Padding = UDim.new(0, 7),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
Create("UIPadding", {
PaddingTop = UDim.new(0, 14),
PaddingLeft = UDim.new(0, 14),
PaddingRight = UDim.new(0, 14),
}),
})
unlockButton = Button.new({
Parent = detailFrame,
Text = "Unlock",
Variant = "primary",
Size = UDim2.new(1, -28, 0, 44),
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.new(0.5, 0, 1, -14),
OnClick = function()
local skill, isCore = lookup(UIState.get("selectedSkill"))
local points = UIState.get("skillPoints") or 0
if not skill then
return
end
if isCore then
local rank = UIState.get("parryRank") or 0
local cost = Parry.upgradeCost(rank)
if not cost or points < cost then
return
end
UIState.patch({ parryRank = rank + 1, skillPoints = points - cost })
return
end
if isUnlocked(skill.id) or points < skill.cost then
return
end
local unlocked = UIState.get("unlockedSkills")
table.insert(unlocked, skill.id)
UIState.patch({ unlockedSkills = unlocked, skillPoints = points - skill.cost })
end,
})
trove:add(unlockButton)
-- The list depends on the chosen style, so it rebuilds with the character.
trove:add(UIState.observe("character", rebuildList))
trove:add(UIState.observe("skillPoints", function(points)
pointsLabel.Text = `{points or 0} skill point{if points == 1 then "" else "s"} available`
renderDetail()
end))
trove:add(UIState.observeMany({ "unlockedSkills", "selectedSkill", "parryRank" }, function()
syncRows()
renderDetail()
end))
trove:add(UIState.observeMany({ "loadout", "level" }, function()
syncStrip()
syncRows()
syncEquipRow()
end))
end
return SkillsTab
]]>
-
StatusTab
-
TitlesTab
-
Objective
0.018 and shown < #fullText do
shown += 1
accumulator -= 0.018
end
line.Text = string.sub(fullText, 1, shown)
if shown >= #fullText then
typing = false
prompt.Text = ""
end
end)
end
--------------------------------------------------------------------------------
function Objective.say(who: string, text: string)
dialogue.Visible = true
speaker.Text = string.upper(who)
fullText = text
shown = 0
typing = true
prompt.Text = "any key to skip"
dialogue.BackgroundTransparency = 1
Motion.to(dialogue, Theme.Time.Base, { BackgroundTransparency = 0.12 })
end
--- Dumps the rest of the line instantly. Nobody should be held hostage by
--- someone explaining how to walk.
function Objective.skipTyping()
if typing then
shown = #fullText
end
end
function Objective.hideDialogue()
local tween = Motion.to(dialogue, Theme.Time.Base, { BackgroundTransparency = 1 })
typing = false
tween.Completed:Once(function()
dialogue.Visible = false
line.Text = ""
speaker.Text = ""
end)
end
function Objective.setObjective(text: string?, index: number?, total: number?)
if not text then
tracker.Visible = false
return
end
tracker.Visible = true
objectiveLabel.Text = text
stepLabel.Text = if index and total then `STEP {index} OF {total}` else ""
progressFill.Size = UDim2.fromScale(0, 1)
end
function Objective.setProgress(fraction: number)
Motion.to(progressFill, Theme.Time.Fast, { Size = UDim2.fromScale(math.clamp(fraction, 0, 1), 1) })
end
function Objective.stop()
trove:clean()
end
return Objective
]]>
-
Shop
= item.price
row(buyList, {
order = index,
name = item.name,
rarity = item.rarity,
price = `{item.price} G`,
affordable = affordable,
subtitle = `{(Theme.Rarity[item.rarity] or Theme.Rarity.Common).Label} · {item.slot or "Item"}`,
description = item.description,
onClick = function()
if affordable then
Network.Interact:FireServer(payload.npcId, "buy", item.id)
else
Audio.play("uiClose")
end
end,
})
end
if #payload.sellable == 0 then
Create("TextLabel", {
Name = "Empty",
Size = UDim2.new(1, -8, 0, 60),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "Nothing they want.",
TextSize = 13,
TextColor3 = Theme.Color.TextDim,
Parent = sellList,
})
else
for index, material in payload.sellable do
row(sellList, {
order = index,
name = `{material.name} ×{material.count}`,
rarity = material.rarity,
price = `+{material.price} G`,
subtitle = "Click to sell one",
onClick = function()
Network.Interact:FireServer(payload.npcId, "sell", material.id)
end,
})
end
end
buyList.CanvasSize = UDim2.fromOffset(0, buyList.UIListLayout.AbsoluteContentSize.Y + 8)
sellList.CanvasSize = UDim2.fromOffset(0, sellList.UIListLayout.AbsoluteContentSize.Y + 8)
end
function Shop.close()
if not Shop.isOpen then
return
end
Shop.isOpen = false
panel:close()
if current then
Network.Interact:FireServer(current.npcId, "close")
end
current = nil
end
local function column(parent: Instance, title: string, xScale: number): ScrollingFrame
local holder = Create("Frame", {
Name = title,
Position = UDim2.fromScale(xScale, 0),
Size = UDim2.new(0.5, -Theme.Space.md, 1, 0),
BackgroundTransparency = 1,
Parent = parent,
})
Create("TextLabel", {
Name = "Header",
Size = UDim2.new(1, 0, 0, 20),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = string.upper(title),
TextSize = 13,
TextColor3 = Theme.Color.TextMuted,
TextXAlignment = Enum.TextXAlignment.Left,
Parent = holder,
})
local list = Create("ScrollingFrame", {
Name = "List",
Position = UDim2.fromOffset(0, 26),
Size = UDim2.new(1, 0, 1, -26),
BackgroundTransparency = 1,
BorderSizePixel = 0,
ScrollBarThickness = 3,
ScrollBarImageColor3 = Theme.Color.Stroke,
CanvasSize = UDim2.new(),
Parent = holder,
Create("UIListLayout", {
Padding = UDim.new(0, 6),
SortOrder = Enum.SortOrder.LayoutOrder,
}),
})
return list
end
function Shop.start()
local root = Layer.root("Menu", "Shop")
panel = Panel.new({
Parent = root,
Size = UDim2.fromOffset(760, 470),
Title = "Shop",
Subtitle = "",
Scrim = true,
OnClose = function()
Shop.close()
end,
})
goldLabel = Create("TextLabel", {
Name = "Gold",
AnchorPoint = Vector2.new(1, 0),
Position = UDim2.new(1, -54, 0, Theme.Space.lg),
Size = UDim2.fromOffset(130, 24),
BackgroundTransparency = 1,
FontFace = Theme.Font.Bold,
Text = "0 G",
TextSize = 18,
TextColor3 = Theme.Color.Unique,
TextXAlignment = Enum.TextXAlignment.Right,
ZIndex = 4,
Parent = panel.Window,
})
local content = Create("Frame", {
Name = "Columns",
Size = UDim2.new(1, -Theme.Space.lg * 2, 1, -Theme.Space.lg),
Position = UDim2.fromOffset(Theme.Space.lg, 0),
BackgroundTransparency = 1,
Parent = panel.Content,
})
buyList = column(content, "For sale", 0)
sellList = column(content, "They'll buy", 0.5)
Network.Shop.OnClientEvent:Connect(function(payload)
if not payload then
if Shop.isOpen then
Shop.isOpen = false
current = nil
panel:close()
end
return
end
panel:setTitle(payload.name)
panel:setSubtitle(payload.greeting or "")
render(payload)
if not Shop.isOpen then
Shop.isOpen = true
panel:open()
end
end)
end
return Shop
]]>
-
TitleScreen
())
root = Layer.root("Frontend", "TitleScreen")
root.Visible = false
trove:add(root)
Create("Frame", {
Name = "Backdrop",
Size = UDim2.fromScale(1, 1),
BackgroundColor3 = Theme.Color.Void,
BorderSizePixel = 0,
Parent = root,
})
-- Slow drifting rule pattern; just enough motion to feel alive.
local drift = Create("Frame", {
Name = "Drift",
Size = UDim2.fromScale(1, 1.4),
Position = UDim2.fromScale(0, -0.2),
BackgroundTransparency = 1,
Parent = root,
})
for index = 1, 10 do
Create("Frame", {
Name = `Rule{index}`,
AnchorPoint = Vector2.new(0, 0.5),
Position = UDim2.fromScale(0, index / 11),
Size = UDim2.new(1, 0, 0, 1),
BackgroundColor3 = Theme.Color.Accent,
BackgroundTransparency = 0.94,
BorderSizePixel = 0,
Parent = drift,
})
end
local offset = 0
trove:connect(RunService.RenderStepped, function(dt)
if not root.Visible then
return
end
offset = (offset + dt * 0.008) % 0.0909
drift.Position = UDim2.fromScale(0, -0.2 + offset)
end)
group = Create("Frame", {
Name = "Group",
AnchorPoint = Vector2.new(0.5, 0.5),
Position = UDim2.fromScale(0.5, 0.5),
Size = UDim2.fromOffset(760, 340),
BackgroundTransparency = 1,
Parent = root,
})
Create("TextLabel", {
Name = "Title",
Position = UDim2.fromScale(0, 0.1),
Size = UDim2.new(1, 0, 0, 60),
BackgroundTransparency = 1,
FontFace = Theme.Font.Black,
Text = "SHANGRI-LA FRONTIER",
TextSize = 46,
TextColor3 = Theme.Color.Text,
Parent = group,
})
Create("Frame", {
Name = "Rule",
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, 76),
Size = UDim2.fromOffset(300, 1),
BackgroundColor3 = Theme.Color.Accent,
BorderSizePixel = 0,
Parent = group,
Create("UIGradient", {
Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 1),
NumberSequenceKeypoint.new(0.5, 0),
NumberSequenceKeypoint.new(1, 1),
}),
}),
})
Create("TextLabel", {
Name = "Tagline",
Position = UDim2.fromOffset(0, 92),
Size = UDim2.new(1, 0, 0, 22),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "A god-tier game, played by someone who only plays trash",
TextSize = 14,
TextColor3 = Theme.Color.TextMuted,
Parent = group,
})
-- Debounced. `onDive` advances the whole front-end a phase, and the button
-- stays on screen through the 0.34s hide tween — long enough for a second
-- click to land and push the player through the transition twice.
local dived = false
local diveButton = Button.new({
Parent = group,
Text = "Dive In",
Variant = "primary",
Size = UDim2.fromOffset(260, 52),
AnchorPoint = Vector2.new(0.5, 0),
Position = UDim2.new(0.5, 0, 0, 172),
OnClick = function()
if dived then
return
end
dived = true
onDive()
end,
})
trove:add(diveButton)
-- Re-armed whenever the screen comes back, so the admin replay works.
TitleScreen._rearm = function()
dived = false
end
Create("TextLabel", {
Name = "Version",
AnchorPoint = Vector2.new(0.5, 1),
Position = UDim2.fromScale(0.5, 1),
Size = UDim2.new(1, 0, 0, 18),
BackgroundTransparency = 1,
FontFace = Theme.Font.Medium,
Text = "v0.1.0 — pre-alpha",
TextSize = 11,
TextColor3 = Theme.Color.TextDim,
Parent = group,
})
end
function TitleScreen.show()
if shown then
return
end
shown = true
if TitleScreen._rearm then
TitleScreen._rearm()
end
root.Visible = true
group.Position = UDim2.fromScale(0.5, 0.53)
Motion.to(group, Theme.Time.Deliberate, { Position = UDim2.fromScale(0.5, 0.5) }, Theme.Ease.Enter)
for _, descendant in group:GetDescendants() do
if descendant:IsA("TextLabel") then
descendant.TextTransparency = 1
Motion.to(descendant, Theme.Time.Deliberate, { TextTransparency = 0 }, Theme.Ease.Standard, 0.1)
end
end
end
function TitleScreen.hide()
if not shown then
return
end
shown = false
local tween = Motion.to(group, Theme.Time.Slow, { Position = UDim2.fromScale(0.5, 0.47) }, Theme.Ease.Exit)
for _, descendant in group:GetDescendants() do
if descendant:IsA("TextLabel") then
Motion.to(descendant, Theme.Time.Slow, { TextTransparency = 1 })
end
end
tween.Completed:Once(function()
if not shown then
root.Visible = false
end
end)
end
function TitleScreen.stop()
trove:clean()
shown = false
end
return TitleScreen
]]>
-
Workspace
2
false
true
2
128
640