-
ReplicatedStorage
-
Shared
-
Cooldown
= entry.max then
entry.nextAt = 0
return
end
if entry.nextAt == 0 then
entry.nextAt = now + entry.interval
return
end
while now >= entry.nextAt and entry.count < entry.max do
entry.count += 1
entry.nextAt = if entry.count >= entry.max then 0 else entry.nextAt + entry.interval
end
end
function Cooldown.consumeCharge(self: Class, key: string): boolean
local entry = self.charges[key]
if not entry then
return false
end
refill(entry, os.clock())
if entry.count <= 0 then
return false
end
entry.count -= 1
if entry.nextAt == 0 then
entry.nextAt = os.clock() + entry.interval
end
return true
end
function Cooldown.chargeCount(self: Class, key: string): number
local entry = self.charges[key]
if not entry then
return 0
end
refill(entry, os.clock())
return entry.count
end
-- 0..1 progress toward the next charge, for the HUD pips.
function Cooldown.chargeProgress(self: Class, key: string): number
local entry = self.charges[key]
if not entry then
return 1
end
refill(entry, os.clock())
if entry.count >= entry.max or entry.nextAt == 0 then
return 1
end
local left = entry.nextAt - os.clock()
return math.clamp(1 - (left / entry.interval), 0, 1)
end
return Cooldown
]]>
-
Hitbox
halfHeight then
continue
end
local flat = Vector3.new(delta.X, 0, delta.Z)
if flat.Magnitude < 0.05 then
table.insert(out, model)
continue
end
local flatForward = Vector3.new(forward.X, 0, forward.Z).Unit
if flat.Unit:Dot(flatForward) >= cosLimit then
table.insert(out, model)
end
end
return out
end
return {}
end
-- Nearest character model in front of the caster, used by Teleport and Grab.
function Hitbox.nearestTarget(origin: CFrame, range: number, ignore: Model?): Model?
local candidates =
collect(Workspace:GetPartBoundsInRadius(origin.Position, range, params(ignore)), ignore)
local best: Model? = nil
local bestDistance = math.huge
for _, model in candidates do
local root = model:FindFirstChild("HumanoidRootPart")
if not root or not root:IsA("BasePart") then
continue
end
local humanoid = model:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then
continue
end
local distance = (root.Position - origin.Position).Magnitude
if distance < bestDistance then
bestDistance = distance
best = model
end
end
return best
end
-- Resolve a knockback spec into a world-space impulse direction.
function Hitbox.knockbackVector(spec, casterCFrame: CFrame, targetPosition: Vector3): Vector3
local mode = spec.mode
local power = spec.power or 0
local lift = spec.lift or 0
-- "Up" and "Down" are purely vertical, so they contribute no horizontal
-- direction at all — `lift` carries the sign. Everything unrecognised
-- falls back to "Forward".
local direction: Vector3
if mode == "Up" or mode == "Down" then
direction = Vector3.zero
elseif mode == "Backward" then
direction = -casterCFrame.LookVector
elseif mode == "Away" then
local flat = targetPosition - casterCFrame.Position
flat = Vector3.new(flat.X, 0, flat.Z)
direction = if flat.Magnitude > 0.05 then flat.Unit else casterCFrame.LookVector
else
direction = casterCFrame.LookVector
end
return Vector3.new(direction.X * power, lift, direction.Z * power)
end
return Hitbox
]]>
-
Net
server. One envelope for every input; see CombatService.
"Action",
-- server -> owning client. Authoritative snapshot the HUD renders from.
"State",
-- server -> all clients. Purely cosmetic cues (hit sparks, move started).
"Effect",
-- client -> server. Character pick.
"SelectCharacter",
}
local Net = {}
local cache: { [string]: RemoteEvent } = {}
local function container(): Folder
if RunService:IsServer() then
local folder = ReplicatedStorage:FindFirstChild(FOLDER_NAME)
if not folder then
folder = Instance.new("Folder")
folder.Name = FOLDER_NAME
folder.Parent = ReplicatedStorage
end
return folder :: Folder
end
return ReplicatedStorage:WaitForChild(FOLDER_NAME) :: Folder
end
function Net.get(name: string): RemoteEvent
local existing = cache[name]
if existing then
return existing
end
local parent = container()
local remote: RemoteEvent
if RunService:IsServer() then
local found = parent:FindFirstChild(name)
if found then
remote = found :: RemoteEvent
else
remote = Instance.new("RemoteEvent")
remote.Name = name
remote.Parent = parent
end
else
remote = parent:WaitForChild(name) :: RemoteEvent
end
cache[name] = remote
return remote
end
-- Server-only: make every remote exist before any client asks for one.
function Net.init()
assert(RunService:IsServer(), "Net.init is server-only")
for _, name in REMOTE_NAMES do
Net.get(name)
end
end
return Net
]]>
-
Powers
shreds block meter instead of being chipped
uncounterable true -> Counter moves cannot catch it
pierce true -> hits every target in the volume, not just the first
rooted true -> caster cannot move for the duration
moveSpeedMultiplier caster speed scale while the move runs (rooted = false)
ultimate true -> gets the highlighted HUD slot
]]
local Universal = require(script.Universal)
local ORDER = {
-- Heroes
"Saitama",
"Garou",
"Genos",
"Sonic",
"Tatsumaki",
"AtomicSamurai",
-- Elements
"Blaze",
"Tide",
"Gale",
"Volt",
"Terra",
"Frost",
}
local Powers = {}
Powers.Universal = Universal
Powers.Order = ORDER
-- id -> character definition
Powers.Characters = {}
-- "Saitama/SeriousPunch" -> move definition, built once so lookups on the hot
-- path never walk the roster.
local moveIndex = {}
for _, id in ORDER do
local character = require(script[id])
Powers.Characters[id] = character
for _, move in character.moves do
moveIndex[`{id}/{move.id}`] = move
end
end
function Powers.getCharacter(characterId: string)
return Powers.Characters[characterId]
end
function Powers.getMove(characterId: string, moveId: string)
return moveIndex[`{characterId}/{moveId}`]
end
function Powers.getMoveBySlot(characterId: string, slot: number)
local character = Powers.Characters[characterId]
if not character then
return nil
end
for _, move in character.moves do
if move.slot == slot then
return move
end
end
return nil
end
function Powers.isValidCharacter(characterId: string): boolean
return Powers.Characters[characterId] ~= nil
end
Powers.DefaultCharacter = ORDER[1]
return Powers
]]>
-
AtomicSamurai
-
Blaze
-
Frost
-
Gale
-
Garou
-
Genos
-
Saitama
-
Sonic
-
Tatsumaki
-
Terra
-
Tide
-
Universal
-
Volt
-
ServerScriptService
-
Server
0
-
CombatService
0.02 then
task.delay(left, function()
if ragdollUntil[model] and os.clock() >= ragdollUntil[model] then
ragdollUntil[model] = nil
Ragdoll.disable(model)
end
end)
return
end
ragdollUntil[model] = nil
Ragdoll.disable(model)
end)
end
-- Bumped per slow so a later, weaker slow expiring cannot clear a stronger one
-- that landed after it.
local slowTokens: { [Model]: number } = {}
local function applySlow(model: Model, victim, spec)
-- Only players have a base walk speed worth scaling; dummies stand still.
if not victim then
return
end
local now = os.clock()
-- A stronger slow always wins; an equal-or-weaker one only extends time.
if now < victim.slowUntil and victim.slowMultiplier < spec.multiplier then
victim.slowUntil = math.max(victim.slowUntil, now + spec.duration)
return
end
victim.slowMultiplier = spec.multiplier
victim.slowUntil = math.max(victim.slowUntil, now + spec.duration)
local token = (slowTokens[model] or 0) + 1
slowTokens[model] = token
task.delay(spec.duration, function()
if slowTokens[model] ~= token then
return
end
if os.clock() >= victim.slowUntil then
victim.slowUntil = 0
victim.slowMultiplier = 1
end
end)
end
local function applyBurn(attacker, model: Model, burn)
task.spawn(function()
for _ = 1, burn.ticks do
task.wait(burn.tickInterval)
local humanoid = model:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then
return
end
humanoid:TakeDamage(burn.damagePerTick)
Net.get("Effect"):FireAllClients("Burn", {
target = model,
source = attacker.player,
characterId = attacker.characterId,
})
end
end)
end
--------------------------------------------------------------------------------
-- the one place damage happens
--------------------------------------------------------------------------------
--[[
Returns true if the hit connected in a way the attacker should see as a hit.
Blocks, counters, barriers, and i-frames all return false.
]]
function CombatService.applyHit(
attacker,
targetModel: Model,
move,
damage: number,
knockback,
isFinisher,
opts
)
local humanoid = targetModel:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then
return false
end
local attackerCharacter = attacker.player.Character
if not attackerCharacter then
return false
end
local attackerRoot = attackerCharacter:FindFirstChild("HumanoidRootPart")
if not attackerRoot or not attackerRoot:IsA("BasePart") then
return false
end
local targetRoot = targetModel:FindFirstChild("HumanoidRootPart")
local defender = fighterForModel(targetModel)
local effects = Net.get("Effect")
local now = os.clock()
-- i-frames
if defender and now < defender.iframesUntil and not move.uncounterable then
effects:FireAllClients("Dodge", { target = targetModel })
return false
end
-- counter stance: send it back at the attacker
if defender and defender.counter and now < defender.counter.expiresAt and not move.uncounterable then
local counterMove = defender.counter.move
local spec = counterMove.counter
defender.counter.triggered = true
local reflected = math.max(damage * spec.reflectMultiplier, spec.minimumDamage)
local attackerHumanoid = attackerCharacter:FindFirstChildOfClass("Humanoid")
if attackerHumanoid then
attackerHumanoid:TakeDamage(reflected)
end
if targetRoot and targetRoot:IsA("BasePart") then
attackerRoot.AssemblyLinearVelocity =
Hitbox.knockbackVector(spec.knockback, targetRoot.CFrame, attackerRoot.Position)
end
applyRagdoll(attackerCharacter, spec.ragdoll, attacker)
effects:FireAllClients("Counter", {
by = defender.player,
against = attacker.player,
move = counterMove.id,
damage = reflected,
})
return false
end
-- psychic barrier: soak, optionally kick some back
if defender and defender.barrier and now < defender.barrier.expiresAt then
local barrier = defender.barrier
local spec = barrier.move.barrier
barrier.remaining -= damage
if spec.reflectFraction and spec.reflectFraction > 0 then
local attackerHumanoid = attackerCharacter:FindFirstChildOfClass("Humanoid")
if attackerHumanoid then
attackerHumanoid:TakeDamage(damage * spec.reflectFraction)
end
end
if barrier.remaining <= 0 then
defender.barrier = nil
effects:FireAllClients("BarrierPop", { user = defender.player })
if targetRoot and targetRoot:IsA("BasePart") then
local blown = Hitbox.query(
targetRoot.CFrame,
{ shape = "Sphere", radius = spec.popRadius, offset = 0 },
targetModel
)
for _, model in blown do
local root = model:FindFirstChild("HumanoidRootPart")
if root and root:IsA("BasePart") then
root.AssemblyLinearVelocity =
Hitbox.knockbackVector(spec.popKnockback, targetRoot.CFrame, root.Position)
end
end
end
else
effects:FireAllClients("BarrierHit", { user = defender.player, remaining = barrier.remaining })
end
return false
end
-- block
local finalDamage = damage
local blocked = false
if defender and defender.block.holding and not defender.block.broken then
local blockCfg = Universal.Block
local drain = damage * blockCfg.meterPerDamage
if move.blockBreak then
-- Block-break moves shred the meter instead of being chipped down.
drain *= 2.5
else
finalDamage = damage * blockCfg.chipMultiplier
blocked = true
end
defender.block.meter -= drain
defender.block.lastDrainAt = now
if defender.block.meter <= 0 then
defender.block.meter = 0
defender.block.broken = true
defender.block.holding = false
defender.stunUntil = now + blockCfg.breakStun
blocked = false
finalDamage = damage
effects:FireAllClients("BlockBreak", { target = targetModel })
elseif blocked then
effects:FireAllClients("Blocked", { target = targetModel })
end
end
humanoid:TakeDamage(finalDamage)
if blocked then
return false
end
-- knockback
if knockback and targetRoot and targetRoot:IsA("BasePart") then
targetRoot.AssemblyLinearVelocity =
Hitbox.knockbackVector(knockback, attackerRoot.CFrame, targetRoot.Position)
end
-- stun vs ragdoll: a ragdoll supersedes a stun, and barrages only ragdoll
-- on the finisher so the victim stays in the string.
local stunOnly = opts and opts.stunOnly
if stunOnly then
if defender then
defender.stunUntil = math.max(defender.stunUntil, now + stunOnly)
end
elseif move.ragdoll and (isFinisher or move.kind ~= "Barrage") then
applyRagdoll(targetModel, move.ragdoll, defender)
if defender then
defender.busy = false
defender.charging = nil
defender.counter = nil
end
elseif move.stun then
if defender then
defender.stunUntil = math.max(defender.stunUntil, now + move.stun)
end
end
if move.burn then
applyBurn(attacker, targetModel, move.burn)
end
if move.slow then
applySlow(targetModel, defender, move.slow)
end
effects:FireAllClients("Damage", {
target = targetModel,
source = attacker.player,
amount = finalDamage,
move = move.id,
})
return true
end
--------------------------------------------------------------------------------
-- input handling
--------------------------------------------------------------------------------
local function canAct(fighter): boolean
local character = fighter.player.Character
if not character then
return false
end
local humanoid = character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then
return false
end
if os.clock() < fighter.stunUntil or isRagdolled(character) then
return false
end
return true
end
local function runMove(fighter, move)
fighter.busy = true
fighter.activeMove = move.id
local ok, result = pcall(MoveRunner.run, fighter, move)
if not ok then
warn(`[SBG] move {move.id} errored: {result}`)
end
fighter.busy = false
fighter.activeMove = nil
-- Releases any held animation pose (charge, counter stance, barrier).
Net.get("Effect"):FireAllClients("MoveEnd", { user = fighter.player })
-- Counter reports whether it caught anything; tryMove uses that to pick
-- which cooldown to charge.
return if ok then result else nil
end
local function tryMove(fighter, slot: number)
if not canAct(fighter) or fighter.busy then
return
end
local move = Powers.getMoveBySlot(fighter.characterId, slot)
if not move then
return
end
if not Cooldown.ready(fighter.cooldowns, move.id) then
return
end
-- Charge moves start their cooldown on release, but every other kind
-- commits the moment it starts so nothing can be double-fired.
Cooldown.start(fighter.cooldowns, move.id, move.cooldown)
if move.kind == "Charge" then
fighter.chargeReleased = false
fighter.charging = { move = move, startedAt = os.clock() }
end
task.spawn(function()
local result = runMove(fighter, move)
fighter.charging = nil
-- A whiffed counter pays a different (usually equal) price.
if move.kind == "Counter" and result == false and move.whiffCooldown then
Cooldown.start(fighter.cooldowns, move.id, move.whiffCooldown)
end
end)
end
local function tryM1(fighter)
if not canAct(fighter) or fighter.busy then
return
end
local m1 = Universal.M1
local now = os.clock()
if now > fighter.comboExpiresAt then
fighter.comboIndex = 0
end
fighter.comboIndex = (fighter.comboIndex % #m1.chain) + 1
fighter.comboExpiresAt = now + m1.comboWindow
local link = m1.chain[fighter.comboIndex]
-- Synthesise a one-off move definition for this link so applyHit and the
-- HUD see the same shape as any other move.
local move = {
id = m1.id,
kind = "Strike",
damage = link.damage,
windup = link.windup,
active = link.active,
endlag = link.endlag,
stun = link.stun,
ragdoll = link.ragdoll,
knockback = link.knockback,
hitbox = m1.hitbox,
rooted = false,
moveSpeedMultiplier = 0.6,
}
task.spawn(runMove, fighter, move)
end
local function tryDash(fighter, direction: Vector3?)
if not canAct(fighter) then
return
end
local dashCfg = Universal.Dash
if fighter.stamina.value < StaminaCfg.dashCost then
return
end
if not Cooldown.consumeCharge(fighter.cooldowns, "Dash") then
return
end
fighter.stamina.value -= StaminaCfg.dashCost
fighter.stamina.lastUseAt = os.clock()
local character = fighter.player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not root or not root:IsA("BasePart") then
return
end
local aim = direction
if not aim or aim.Magnitude < 0.05 then
aim = root.CFrame.LookVector
else
aim = aim.Unit
end
fighter.iframesUntil = os.clock() + dashCfg.iframes
Net.get("Effect"):FireAllClients("Dash", { user = fighter.player })
task.spawn(function()
local speed = dashCfg.distance / dashCfg.duration
local elapsed = 0
while elapsed < dashCfg.duration do
local currentRoot = character and character:FindFirstChild("HumanoidRootPart")
if not currentRoot or not currentRoot:IsA("BasePart") then
break
end
currentRoot.AssemblyLinearVelocity = (aim :: Vector3) * speed + Vector3.new(0, 6, 0)
elapsed += task.wait()
end
end)
end
local function tryGetup(fighter)
local character = fighter.player.Character
if not character or not isRagdolled(character) then
return
end
local getupCfg = Universal.Getup
local now = os.clock()
if now - (fighter.lastGetupAt or 0) < getupCfg.pressCooldown then
return
end
fighter.lastGetupAt = now
local until_ = ragdollUntil[character]
if not until_ then
return
end
-- Never let mashing skip more than (1 - floor) of the original knockdown.
local floorAt = fighter.ragdollFloor or 0
ragdollUntil[character] = math.max(floorAt, until_ - getupCfg.reductionPerPress)
end
local function setBlocking(fighter, holding: boolean)
if holding and (not canAct(fighter) or fighter.block.broken) then
return
end
fighter.block.holding = holding
if not holding then
fighter.block.lastDrainAt = os.clock()
end
end
local function setSprinting(fighter, sprinting: boolean)
fighter.stamina.sprinting = sprinting
-- WalkSpeed itself is applied by step(), which reconciles sprint, stamina,
-- and slow together.
end
--------------------------------------------------------------------------------
-- regen + state replication
--------------------------------------------------------------------------------
local function snapshot(fighter)
local character = fighter.player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
local definition = Powers.getCharacter(fighter.characterId)
local cooldowns = {}
for _, move in definition.moves do
cooldowns[move.id] = Cooldown.remaining(fighter.cooldowns, move.id)
end
local now = os.clock()
local charging = nil
if fighter.charging then
local move = fighter.charging.move
local held = now - fighter.charging.startedAt
charging = {
moveId = move.id,
ratio = math.clamp(
(held - move.charge.min) / math.max(move.charge.max - move.charge.min, 0.001),
0,
1
),
}
end
return {
characterId = fighter.characterId,
health = if humanoid then humanoid.Health else 0,
maxHealth = if humanoid then humanoid.MaxHealth else definition.maxHealth,
block = {
meter = fighter.block.meter,
max = Universal.Block.maxMeter,
holding = fighter.block.holding,
broken = fighter.block.broken,
},
stamina = { value = fighter.stamina.value, max = StaminaCfg.max },
dash = {
count = Cooldown.chargeCount(fighter.cooldowns, "Dash"),
max = Universal.Dash.charges,
progress = Cooldown.chargeProgress(fighter.cooldowns, "Dash"),
},
cooldowns = cooldowns,
stun = math.max(0, fighter.stunUntil - now),
ragdoll = if character and ragdollUntil[character]
then math.max(0, ragdollUntil[character] - now)
else 0,
busy = fighter.busy,
charging = charging,
barrier = if fighter.barrier and now < fighter.barrier.expiresAt
then fighter.barrier.remaining
else nil,
}
end
local function step(dt: number)
local now = os.clock()
local blockCfg = Universal.Block
local sprintCfg = Universal.Sprint
for player, fighter in fighters do
-- block meter
if not fighter.block.holding and now - fighter.block.lastDrainAt > blockCfg.regenDelay then
fighter.block.meter =
math.min(blockCfg.maxMeter, fighter.block.meter + blockCfg.regenPerSecond * dt)
if fighter.block.broken and fighter.block.meter >= blockCfg.maxMeter * 0.5 then
fighter.block.broken = false
end
end
-- stamina
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
local moving = humanoid ~= nil and humanoid.MoveDirection.Magnitude > 0.1
if fighter.stamina.sprinting and moving and fighter.stamina.value > 0 then
fighter.stamina.value = math.max(0, fighter.stamina.value - sprintCfg.staminaPerSecond * dt)
fighter.stamina.lastUseAt = now
elseif now - fighter.stamina.lastUseAt > StaminaCfg.regenDelay then
fighter.stamina.value =
math.min(StaminaCfg.max, fighter.stamina.value + StaminaCfg.regenPerSecond * dt)
end
-- One place owns WalkSpeed whenever a move is not deliberately holding
-- the player still. Sprinting, running dry, and Frost's slow all just
-- feed into this, instead of each poking WalkSpeed and fighting.
if humanoid and not fighter.busy then
local target = Powers.getCharacter(fighter.characterId).walkSpeed
if fighter.stamina.sprinting and fighter.stamina.value > 1 then
target = sprintCfg.sprintSpeed
end
if now < fighter.slowUntil then
target *= fighter.slowMultiplier
end
if math.abs(humanoid.WalkSpeed - target) > 0.01 then
humanoid.WalkSpeed = target
end
end
end
end
--------------------------------------------------------------------------------
-- wiring
--------------------------------------------------------------------------------
local ACTIONS = {
Move = function(fighter, payload)
local slot = tonumber(payload and payload.slot)
if slot and slot >= 1 and slot <= 4 then
tryMove(fighter, slot)
end
end,
MoveRelease = function(fighter, payload)
local slot = tonumber(payload and payload.slot)
if fighter.charging and slot and fighter.charging.move.slot == slot then
fighter.chargeReleased = true
end
end,
M1 = function(fighter)
tryM1(fighter)
end,
Block = function(fighter, payload)
setBlocking(fighter, payload and payload.holding == true)
end,
Dash = function(fighter, payload)
local direction = nil
if payload and typeof(payload.direction) == "Vector3" then
direction = payload.direction
end
tryDash(fighter, direction)
end,
Sprint = function(fighter, payload)
setSprinting(fighter, payload and payload.holding == true)
end,
Getup = function(fighter)
tryGetup(fighter)
end,
}
local function onCharacterAdded(player: Player, character: Model)
local fighter = fighters[player]
if not fighter then
return
end
-- Reset everything a fresh body should not inherit.
fighter.busy = false
fighter.activeMove = nil
fighter.counter = nil
fighter.barrier = nil
fighter.charging = nil
fighter.stunUntil = 0
fighter.iframesUntil = 0
fighter.slowUntil = 0
fighter.slowMultiplier = 1
fighter.block.meter = Universal.Block.maxMeter
fighter.block.broken = false
fighter.block.holding = false
fighter.stamina.value = StaminaCfg.max
ragdollUntil[character] = nil
local definition = Powers.getCharacter(fighter.characterId)
local humanoid = character:WaitForChild("Humanoid") :: Humanoid
humanoid.MaxHealth = definition.maxHealth
humanoid.Health = definition.maxHealth
humanoid.WalkSpeed = definition.walkSpeed
humanoid.Died:Connect(function()
ragdollUntil[character] = nil
fighter.busy = false
end)
end
function CombatService.start()
Net.init()
MoveRunner.init(CombatService)
local function bind(player: Player)
fighters[player] = newFighter(player)
player.CharacterAdded:Connect(function(character)
onCharacterAdded(player, character)
end)
if player.Character then
onCharacterAdded(player, player.Character)
end
end
Players.PlayerAdded:Connect(bind)
for _, player in Players:GetPlayers() do
bind(player)
end
Players.PlayerRemoving:Connect(function(player)
fighters[player] = nil
end)
Net.get("Action").OnServerEvent:Connect(function(player, action, payload)
local fighter = fighters[player]
if not fighter or typeof(action) ~= "string" then
return
end
local handler = ACTIONS[action]
if handler then
handler(fighter, payload)
end
end)
Net.get("SelectCharacter").OnServerEvent:Connect(function(player, characterId)
local fighter = fighters[player]
if not fighter or typeof(characterId) ~= "string" then
return
end
if not Powers.isValidCharacter(characterId) or fighter.busy then
return
end
fighter.characterId = characterId
fighter.cooldowns = Cooldown.new()
Cooldown.defineCharges(
fighter.cooldowns,
"Dash",
Universal.Dash.charges,
Universal.Dash.rechargePerCharge
)
local character = player.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid then
local definition = Powers.getCharacter(characterId)
humanoid.MaxHealth = definition.maxHealth
humanoid.Health = definition.maxHealth
humanoid.WalkSpeed = definition.walkSpeed
end
end)
RunService.Heartbeat:Connect(step)
-- Replicate at a fixed rate; the HUD ticks cooldowns locally between frames.
task.spawn(function()
local state = Net.get("State")
while true do
for player, fighter in fighters do
if player.Parent then
state:FireClient(player, snapshot(fighter))
end
end
task.wait(1 / 12)
end
end)
end
return CombatService
]]>
-
MoveRunner
= 1 then
break
end
if combat.applyHit(fighter, target, move, move.damage * scale, move.knockback) then
landed += 1
end
end
if landed > 0 then
emit("Hit", { position = root.Position, characterId = fighter.characterId, move = move.id })
end
return landed
end
local KINDS = {}
function KINDS.Strike(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
if combat.interrupted(fighter) then
release()
return
end
local elapsed = 0
local active = move.active or 0.15
-- Sample across the active window so fast movers cannot walk through it.
while elapsed < active do
if (strike(fighter, move) or 0) > 0 then
break
end
elapsed += task.wait()
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Barrage(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
for index = 1, move.hits do
if combat.interrupted(fighter) then
break
end
local isLast = index == move.hits
local root = rootOf(fighter)
if not root then
break
end
local damage = move.damage
local knockback = move.knockback
if isLast and move.finisher then
damage = move.finisher.damage
knockback = move.finisher.knockback
end
local targets = Hitbox.query(root.CFrame, move.hitbox, fighter.player.Character)
for _, target in targets do
combat.applyHit(fighter, target, move, damage, knockback, isLast)
if not move.pierce then
break
end
end
emit("Hit", {
position = root.Position,
characterId = fighter.characterId,
move = move.id,
tick = index,
-- The last tick of a barrage is the finisher, so it gets the full
-- impact treatment instead of another small tick pop.
heavy = isLast,
})
task.wait(move.hitInterval)
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Charge(fighter, move)
local release = lock(fighter, move)
-- The charge pose is held until release, so it needs no duration.
emit("ChargeStart", {
user = fighter.player,
characterId = fighter.characterId,
move = move.id,
animation = move.chargeAnimation or "ChargeUp",
})
local startedAt = os.clock()
local minHold, maxHold = move.charge.min, move.charge.max
-- Poll for release. `chargeReleased` is set by CombatService when the
-- client sends the key-up, and we hard-stop at maxHold either way.
while true do
local held = os.clock() - startedAt
if held >= maxHold then
break
end
if fighter.chargeReleased and held >= minHold then
break
end
if combat.interrupted(fighter) then
fighter.chargeReleased = false
release()
emit("ChargeCancel", { user = fighter.player, characterId = fighter.characterId, move = move.id })
return
end
-- Gravity Crush and friends drag targets in while charging.
if move.pull then
local root = rootOf(fighter)
if root then
local nearby = Hitbox.query(
root.CFrame,
{ shape = "Sphere", radius = move.pull.radius, offset = 0 },
fighter.player.Character
)
for _, target in nearby do
local targetRoot = target:FindFirstChild("HumanoidRootPart")
if targetRoot and targetRoot:IsA("BasePart") then
local toCaster = root.Position - targetRoot.Position
if toCaster.Magnitude > 6 then
targetRoot.AssemblyLinearVelocity = toCaster.Unit * move.pull.power
end
end
end
end
end
task.wait()
end
local held = math.clamp(os.clock() - startedAt, minHold, maxHold)
local ratio = (held - minHold) / math.max(maxHold - minHold, 0.001)
local damage = move.damage + (move.maxDamage - move.damage) * ratio
fighter.chargeReleased = false
local releasePayload = startPayload(fighter, move)
releasePayload.ratio = ratio
emit("ChargeRelease", releasePayload)
task.wait(move.windup)
if not combat.interrupted(fighter) then
local root = rootOf(fighter)
if root then
local targets = Hitbox.query(root.CFrame, move.hitbox, fighter.player.Character)
for _, target in targets do
combat.applyHit(fighter, target, move, damage, move.knockback, true)
if not move.pierce then
break
end
end
emit("Hit", {
position = root.Position,
characterId = fighter.characterId,
move = move.id,
heavy = true,
})
end
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Counter(fighter, move)
local release = lock(fighter, move)
-- Held until the window closes or something lands on it.
emit("CounterStance", {
user = fighter.player,
characterId = fighter.characterId,
move = move.id,
animation = move.animation,
})
fighter.counter = {
move = move,
expiresAt = os.clock() + move.counter.window,
triggered = false,
}
local deadline = os.clock() + move.counter.window
while os.clock() < deadline do
if fighter.counter and fighter.counter.triggered then
break
end
task.wait()
end
local triggered = fighter.counter ~= nil and fighter.counter.triggered
fighter.counter = nil
if not triggered then
emit("CounterWhiff", { user = fighter.player, characterId = fighter.characterId, move = move.id })
end
task.wait(move.endlag or 0)
release()
return triggered
end
function KINDS.Dash(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
if combat.interrupted(fighter) then
release()
return
end
local root = rootOf(fighter)
if not root then
release()
return
end
local direction = root.CFrame.LookVector
local travelTime = move.dash.distance / move.dash.speed
local velocity = direction * move.dash.speed + Vector3.new(0, move.dash.lift or 0, 0)
local elapsed = 0
local alreadyHit: { [Model]: boolean } = {}
while elapsed < travelTime do
local currentRoot = rootOf(fighter)
if not currentRoot or combat.interrupted(fighter) then
break
end
currentRoot.AssemblyLinearVelocity = velocity
local targets = Hitbox.query(currentRoot.CFrame, move.hitbox, fighter.player.Character)
for _, target in targets do
if alreadyHit[target] then
continue
end
alreadyHit[target] = true
combat.applyHit(fighter, target, move, move.damage, move.knockback, true)
emit("Hit", {
position = currentRoot.Position,
characterId = fighter.characterId,
move = move.id,
})
-- Blade Rush cuts through and keeps going; everything else stops.
if not move.dash.passThrough then
elapsed = travelTime
end
end
elapsed += task.wait()
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Projectile(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
local root = rootOf(fighter)
if not root or combat.interrupted(fighter) then
release()
return
end
local spec = move.projectile
local origin = root.CFrame
-- Projectiles wear the caster's colours.
local definition = Powers.getCharacter(fighter.characterId)
local primary = if definition then definition.color else Color3.fromRGB(240, 240, 255)
local secondary = if definition then definition.accent or primary else primary
for index = 1, spec.count do
-- Fan the volley evenly around the aim line.
local offset = 0
if spec.count > 1 then
offset = ((index - 1) / (spec.count - 1) - 0.5) * spec.spread * 2
end
local aim = origin * CFrame.Angles(0, math.rad(-offset), 0)
task.spawn(function()
local part = Instance.new("Part")
part.Name = `{move.id}_Projectile`
part.Size = spec.size
part.CFrame = aim * CFrame.new(0, 1, -3)
part.CanCollide = false
part.CanQuery = false
part.CanTouch = false
part.CastShadow = false
part.Anchored = true
part.Material = Enum.Material.Neon
part.Color = primary
part.Parent = workspace
Debris:AddItem(part, spec.lifetime + 0.1)
-- Dressed here rather than broadcast, so a five-shard volley costs
-- one replicated part each instead of five extra events.
local light = Instance.new("PointLight")
light.Color = primary
light.Range = 14
light.Brightness = 3
light.Parent = part
local a0 = Instance.new("Attachment")
a0.Position = Vector3.new(0, 0, spec.size.Z * 0.5)
a0.Parent = part
local a1 = Instance.new("Attachment")
a1.Position = Vector3.new(0, 0, -spec.size.Z * 0.5)
a1.Parent = part
local trail = Instance.new("Trail")
trail.Attachment0 = a0
trail.Attachment1 = a1
trail.Color = ColorSequence.new(primary, secondary)
trail.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0.1),
NumberSequenceKeypoint.new(1, 1),
})
trail.Lifetime = 0.4
trail.LightEmission = 1
trail.LightInfluence = 0
trail.WidthScale = NumberSequence.new(1.6, 0)
trail.FaceCamera = true
trail.Parent = part
local velocity = aim.LookVector * spec.speed
local elapsed = 0
while elapsed < spec.lifetime do
local dt = RunService.Heartbeat:Wait()
elapsed += dt
if spec.gravity and spec.gravity > 0 then
velocity -= Vector3.new(0, spec.gravity * dt, 0)
end
part.CFrame = CFrame.new(part.Position + velocity * dt, part.Position + velocity)
local struck = Hitbox.query(
part.CFrame,
{ shape = "Sphere", radius = 3, offset = 0 },
fighter.player.Character
)
if #struck > 0 then
combat.applyHit(fighter, struck[1], move, move.damage, move.knockback, true)
if spec.explode then
local splash = Hitbox.query(
part.CFrame,
{ shape = "Sphere", radius = spec.explode.radius, offset = 0 },
fighter.player.Character
)
for _, extra in splash do
if extra ~= struck[1] then
combat.applyHit(fighter, extra, move, spec.explode.damage, move.knockback)
end
end
end
emit("Explode", {
position = part.Position,
characterId = fighter.characterId,
move = move.id,
})
part:Destroy()
return
end
end
part:Destroy()
end)
task.wait(0.05)
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Teleport(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
local root = rootOf(fighter)
if not root then
release()
return
end
local target = Hitbox.nearestTarget(root.CFrame, move.teleport.range, fighter.player.Character)
if target then
local targetRoot = target:FindFirstChild("HumanoidRootPart")
if targetRoot and targetRoot:IsA("BasePart") then
emit("Teleport", {
user = fighter.player,
characterId = fighter.characterId,
from = root.Position,
to = targetRoot.Position,
move = move.id,
})
-- Land behind them, facing their back.
local behind = targetRoot.CFrame * CFrame.new(0, 0, move.teleport.behindOffset)
root.CFrame = CFrame.new(behind.Position, targetRoot.Position)
fighter.iframesUntil = os.clock() + move.teleport.iframes
end
end
task.wait(move.endlag or 0)
release()
end
function KINDS.Grab(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
local root = rootOf(fighter)
if not root or combat.interrupted(fighter) then
release()
return
end
local target = Hitbox.nearestTarget(root.CFrame, move.grab.range, fighter.player.Character)
if not target then
emit("GrabWhiff", { user = fighter.player, characterId = fighter.characterId, move = move.id })
task.wait(move.endlag or 0)
release()
return
end
local targetRoot = target:FindFirstChild("HumanoidRootPart")
if not targetRoot or not targetRoot:IsA("BasePart") then
release()
return
end
combat.applyHit(fighter, target, move, move.damage, nil, false, { stunOnly = move.grab.holdDuration })
emit(
"Grab",
{ user = fighter.player, characterId = fighter.characterId, target = target, move = move.id }
)
-- Suspend them in front of the caster for the hold.
local heldUntil = os.clock() + move.grab.holdDuration
while os.clock() < heldUntil do
local currentRoot = rootOf(fighter)
if not currentRoot or combat.interrupted(fighter) then
break
end
targetRoot.AssemblyLinearVelocity = Vector3.zero
targetRoot.CFrame = currentRoot.CFrame * CFrame.new(0, 6, -12)
task.wait()
end
combat.applyHit(fighter, target, move, move.grab.slamDamage, move.knockback, true)
emit("Slam", {
position = targetRoot.Position,
characterId = fighter.characterId,
move = move.id,
})
task.wait(move.endlag or 0)
release()
end
function KINDS.Barrier(fighter, move)
local release = lock(fighter, move)
fighter.barrier = {
move = move,
remaining = move.barrier.absorb,
expiresAt = os.clock() + move.barrier.duration,
}
emit("BarrierUp", {
user = fighter.player,
characterId = fighter.characterId,
move = move.id,
animation = move.animation,
})
task.wait(move.endlag or 0)
release()
-- Let it lapse on its own; applyHit pops it early if it runs out.
task.delay(move.barrier.duration, function()
if fighter.barrier and fighter.barrier.move == move then
fighter.barrier = nil
emit("BarrierDown", { user = fighter.player, characterId = fighter.characterId, move = move.id })
end
end)
end
function KINDS.Sustained(fighter, move)
local release = lock(fighter, move)
emit("MoveStart", startPayload(fighter, move))
task.wait(move.windup)
local deadline = os.clock() + move.sustained.duration
while os.clock() < deadline do
if combat.interrupted(fighter) then
break
end
local root = rootOf(fighter)
if not root then
break
end
local targets = Hitbox.query(root.CFrame, move.hitbox, fighter.player.Character)
for _, target in targets do
combat.applyHit(fighter, target, move, move.damage, move.knockback)
end
emit("Sustain", {
user = fighter.player,
characterId = fighter.characterId,
move = move.id,
position = root.Position,
})
task.wait(move.sustained.tickInterval)
end
task.wait(move.endlag or 0)
release()
end
function MoveRunner.run(fighter, move)
local handler = KINDS[move.kind]
if not handler then
warn(`[SBG] no handler for move kind "{move.kind}" ({move.id})`)
return
end
return handler(fighter, move)
end
return MoveRunner
]]>
-
Ragdoll
-
TrainingDummies
0 and humanoid.Health < humanoid.MaxHealth then
if now - entry.lastDamagedAt > CONFIG.regenDelay then
humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + CONFIG.regenPerSecond * dt)
entry.lastHealth = humanoid.Health
end
end
if entry.fill then
entry.fill.Size = UDim2.fromScale(math.clamp(humanoid.Health / humanoid.MaxHealth, 0, 1), 1)
end
end
end
function TrainingDummies.start()
local container = Workspace:FindFirstChild("Dummies")
if not container then
container = Instance.new("Folder")
container.Name = "Dummies"
container.Parent = Workspace
end
for index = 1, CONFIG.count do
local entry = {
index = index,
container = container,
model = nil,
humanoid = nil,
fill = nil,
lastDamagedAt = 0,
lastHealth = CONFIG.health,
dead = false,
}
table.insert(dummies, entry)
spawnDummy(entry)
end
RunService.Heartbeat:Connect(step)
-- The spawn point may not exist until the first player arrives; if the
-- dummies were placed at the origin, put them where they belong now.
Players.PlayerAdded:Connect(function()
task.delay(1, function()
for _, entry in dummies do
if entry.model and not entry.dead then
entry.model:PivotTo(placementFor(entry.index))
end
end
end)
end)
end
return TrainingDummies
]]>
-
StarterPlayer
-
StarterPlayerScripts
-
Client
-
Animation
-
Clips
-
Rig
Motor6D name, per rig
local R6 = {
Torso = "RootJoint",
Head = "Neck",
RightArm = "Right Shoulder",
LeftArm = "Left Shoulder",
RightLeg = "Right Hip",
LeftLeg = "Left Hip",
}
local R15 = {
Torso = "Waist",
Head = "Neck",
RightArm = "RightShoulder",
LeftArm = "LeftShoulder",
RightForearm = "RightElbow",
LeftForearm = "LeftElbow",
RightLeg = "RightHip",
LeftLeg = "LeftHip",
}
-- Mirroring a clip swaps sides and flips the two axes that carry handedness.
local MIRROR_PAIRS = {
RightArm = "LeftArm",
LeftArm = "RightArm",
RightForearm = "LeftForearm",
LeftForearm = "RightForearm",
RightLeg = "LeftLeg",
LeftLeg = "RightLeg",
Torso = "Torso",
Head = "Head",
}
export type Class = typeof(setmetatable(
{} :: {
character: Model,
motors: { [string]: Motor6D },
rigType: string,
},
Rig
))
local function findMotor(character: Model, name: string): Motor6D?
for _, descendant in character:GetDescendants() do
if descendant:IsA("Motor6D") and descendant.Name == name then
return descendant
end
end
return nil
end
function Rig.bind(character: Model): Class?
local humanoid = character:FindFirstChildOfClass("Humanoid")
if not humanoid then
return nil
end
local isR6 = humanoid.RigType == Enum.HumanoidRigType.R6
local map = if isR6 then R6 else R15
local motors: { [string]: Motor6D } = {}
for logical, motorName in map do
local motor = findMotor(character, motorName)
if motor then
motors[logical] = motor
end
end
if not next(motors) then
return nil
end
return setmetatable({
character = character,
motors = motors,
rigType = if isR6 then "R6" else "R15",
}, Rig) :: any
end
function Rig.mirrorPose(pose: { [string]: CFrame }): { [string]: CFrame }
local out = {}
for logical, cf in pose do
local target = MIRROR_PAIRS[logical] or logical
local x, y, z = cf:ToEulerAnglesXYZ()
local px, py, pz = cf.Position.X, cf.Position.Y, cf.Position.Z
-- Flip yaw and roll, keep pitch; mirror sideways translation.
out[target] = CFrame.new(-px, py, pz) * CFrame.Angles(x, -y, -z)
end
return out
end
function Rig.isAlive(self: Class): boolean
if not self.character.Parent then
return false
end
local humanoid = self.character:FindFirstChildOfClass("Humanoid")
return humanoid ~= nil and humanoid.Health > 0
end
-- Ragdolled characters have their Motor6Ds disabled outright, so posing them
-- would fight the physics.
function Rig.isPosable(self: Class): boolean
return Rig.isAlive(self) and self.character:FindFirstChild("RagdollJoints") == nil
end
function Rig.apply(self: Class, pose: { [string]: CFrame }, weight: number)
if weight <= 0 then
return
end
for logical, motor in self.motors do
local target = pose[logical]
if not target then
continue
end
if not motor.Parent then
continue
end
-- Blend from wherever the default animations left the joint this frame,
-- so a partial-weight pose layers on top of the walk cycle instead of
-- snapping over it.
motor.Transform = if weight >= 1
then target
else motor.Transform:Lerp(target, math.clamp(weight, 0, 1))
end
end
return Rig
]]>
-
Track
0.0001 then (t - previous.t) / span else 1
local blended = {}
for logical, from in previous.pose do
local to = key.pose[logical] or from
blended[logical] = from:Lerp(to, alpha)
end
return blended
end
previous = key
end
return previous.pose
end
-- Returns pose, weight. `finished` on self tells the manager to drop it.
function Track.sample(self: Class, dt: number)
self.elapsed += dt
local raw = self.elapsed / self.length
local t: number
if self.clip.loop then
t = raw % 1
elseif self.clip.hold then
t = math.min(raw, 1)
else
t = math.min(raw, 1)
if raw >= 1 and not self.stopping then
Track.stop(self)
end
end
local weight = math.clamp(self.elapsed / math.max(self.fadeIn, 0.0001), 0, 1)
if self.stopping then
self.stopElapsed += dt
local out = 1 - math.clamp(self.stopElapsed / math.max(self.fadeOut, 0.0001), 0, 1)
weight = math.min(weight, out)
if out <= 0 then
self.finished = true
end
end
return poseAt(self.keys, t), weight
end
return Track
]]>
-
Effects
() } } = {}
local barriers: { [Player]: RBXScriptConnection } = {}
local function characterOf(player): Model?
return if typeof(player) == "Instance" and player:IsA("Player") then player.Character else nil
end
local function rootOf(player): BasePart?
local character = characterOf(player)
if not character then
return nil
end
local root = character:FindFirstChild("HumanoidRootPart")
return if root and root:IsA("BasePart") then root else nil
end
local function track(player: Player, stop: () -> ())
local list = running[player]
if not list then
list = {}
running[player] = list
end
table.insert(list, stop)
end
local function clearRunning(player)
local list = running[player]
if not list then
return
end
running[player] = nil
for _, stop in list do
pcall(stop)
end
end
-- Shake falls off with distance so someone else's ultimate across the map does
-- not rattle your screen.
local function shakeFrom(position: Vector3, magnitude: number, duration: number)
local root = rootOf(LocalPlayer)
if not root then
return
end
local distance = (root.Position - position).Magnitude
local falloff = math.clamp(1 - distance / 120, 0, 1)
if falloff <= 0.02 then
return
end
Vfx.shake(magnitude * falloff, duration)
end
--------------------------------------------------------------------------------
-- signature ultimate releases
--------------------------------------------------------------------------------
local SIGNATURE = {}
local function lanceFor(payload, paint, length: number, width: number)
local root = rootOf(payload.user)
if not root then
return
end
Vfx.beam(root.Position, root.CFrame.LookVector, paint, { length = length, width = width })
Vfx.ring(root.CFrame * CFrame.Angles(math.pi / 2, 0, 0), paint, { radius = 10, duration = 0.35 })
shakeFrom(root.Position, 1.4, 0.4)
end
local function eruptionFor(payload, paint, count: number, spread: number)
local root = rootOf(payload.user)
if not root then
return
end
-- Pillars march outward in a ragged ring rather than all at once.
for index = 1, count do
local angle = (index / count) * math.pi * 2
local distance = spread * (0.45 + (index % 3) * 0.28)
local offset = Vector3.new(math.cos(angle) * distance, -2.5, math.sin(angle) * distance)
task.delay(index * 0.035, function()
Vfx.pillar(root.Position + offset, paint, { height = 18 + (index % 4) * 5, width = 3.5 })
end)
end
Vfx.ring(CFrame.new(root.Position - Vector3.new(0, 2.5, 0)), paint, { radius = spread, duration = 0.5 })
Vfx.burst(root.Position, paint, { count = 40, scale = 1.6 })
shakeFrom(root.Position, 2, 0.55)
end
local function implosionFor(payload, paint, radius: number)
local root = rootOf(payload.user)
if not root then
return
end
Vfx.dome(root.Position, paint, { radius = radius, duration = 0.45 })
Vfx.ring(CFrame.new(root.Position - Vector3.new(0, 2.5, 0)), paint, { radius = radius, duration = 0.5 })
Vfx.burst(root.Position, paint, { count = 46, scale = 1.5 })
shakeFrom(root.Position, 1.8, 0.5)
end
function SIGNATURE.SeriousPunch(payload, paint)
local root = rootOf(payload.user)
if not root then
return
end
-- Three rings staggered down the punch line reads as the air itself moving.
for index = 0, 2 do
task.delay(index * 0.05, function()
local at = root.CFrame * CFrame.new(0, 0, -8 - index * 12)
Vfx.ring(at * CFrame.Angles(math.pi / 2, 0, 0), paint, {
radius = 12 + index * 6,
duration = 0.45,
thickness = 1.1,
})
end)
end
Vfx.beam(root.Position, root.CFrame.LookVector, paint, { length = 46, width = 7, duration = 0.35 })
Vfx.burst(root.Position + root.CFrame.LookVector * 5, paint, { count = 50, scale = 1.8 })
shakeFrom(root.Position, 3, 0.6)
end
function SIGNATURE.IncinerationCannon(payload, paint)
lanceFor(payload, paint, 62, 8)
end
function SIGNATURE.Thunderclap(payload, paint)
lanceFor(payload, paint, 58, 6)
-- Forked branches off the main bolt.
local root = rootOf(payload.user)
if root then
for index = 1, 5 do
local lateral = (math.random() - 0.5) * 26
local along = 12 + math.random() * 34
local at = root.CFrame * CFrame.new(lateral, math.random() * 6 - 2, -along)
task.delay(index * 0.02, function()
Vfx.beam(
at.Position,
Vector3.new(0, -1, 0),
paint,
{ length = 14, width = 1.4, duration = 0.25 }
)
end)
end
end
end
function SIGNATURE.GravityCrush(payload, paint)
implosionFor(payload, paint, 22)
end
function SIGNATURE.Maelstrom(payload, paint)
implosionFor(payload, paint, 21)
end
function SIGNATURE.Eruption(payload, paint)
eruptionFor(payload, paint, 10, 18)
end
function SIGNATURE.Fissure(payload, paint)
eruptionFor(payload, paint, 8, 22)
end
function SIGNATURE.AbsoluteZero(payload, paint)
eruptionFor(payload, paint, 12, 20)
end
function SIGNATURE.Tempest(payload, paint)
local root = rootOf(payload.user)
if not root then
return
end
-- Vortex: a tall column plus rings climbing it.
Vfx.pillar(root.Position - Vector3.new(0, 2, 0), paint, { height = 40, width = 9, duration = 0.7 })
for index = 0, 3 do
task.delay(index * 0.06, function()
local at = CFrame.new(root.Position + Vector3.new(0, index * 7 - 2, 0))
Vfx.ring(at, paint, { radius = 20 - index * 3, duration = 0.5 })
end)
end
Vfx.burst(root.Position, paint, { count = 44, scale = 1.6 })
shakeFrom(root.Position, 1.9, 0.55)
end
--------------------------------------------------------------------------------
-- generic per-kind dressing
--------------------------------------------------------------------------------
local function startMoveVisuals(payload)
local paint = Palette.get(payload.characterId)
local character = characterOf(payload.user)
if not character then
return
end
local move = if payload.characterId and payload.move
then Powers.getMove(payload.characterId, payload.move)
else nil
local kind = if move then move.kind else "Strike"
if kind == "Sustained" then
track(payload.user, Vfx.cone(character, paint, { rate = 110, angle = 24 }))
return
end
if kind == "Barrage" then
-- Both arms, since a barrage alternates.
track(payload.user, Vfx.trail(character, paint, { limb = "Right Arm" }))
track(payload.user, Vfx.trail(character, paint, { limb = "Left Arm" }))
return
end
if kind == "Dash" then
track(payload.user, Vfx.trail(character, paint, { limb = "Right Arm", lifetime = 0.4 }))
track(payload.user, Vfx.trail(character, paint, { limb = "Torso", lifetime = 0.4 }))
Vfx.afterimage(character, paint, { duration = 0.3 })
return
end
if kind == "Projectile" then
local root = rootOf(payload.user)
if root then
Vfx.burst(root.Position + root.CFrame.LookVector * 3 + Vector3.new(0, 1, 0), paint, {
count = 12,
scale = 0.7,
})
end
return
end
if kind == "Grab" then
local stop = Vfx.aura(character, paint, { rate = 30, scale = 0.8 })
track(payload.user, stop)
return
end
-- Strike and anything unclassified.
track(payload.user, Vfx.trail(character, paint, { limb = "Right Arm" }))
if move and move.ultimate then
local stop = Vfx.aura(character, paint, { rate = 60 })
track(payload.user, stop)
end
end
--------------------------------------------------------------------------------
-- handlers
--------------------------------------------------------------------------------
local HANDLERS = {}
function HANDLERS.MoveStart(payload)
clearRunning(payload.user)
startMoveVisuals(payload)
end
function HANDLERS.MoveEnd(payload)
clearRunning(payload.user)
end
function HANDLERS.Hit(payload)
if not payload.position then
return
end
local paint = Palette.get(payload.characterId)
local heavy = payload.heavy == true
Vfx.burst(payload.position, paint, {
count = if heavy then 34 else 14,
scale = if heavy then 1.5 else 0.8,
})
if heavy then
Vfx.ring(CFrame.new(payload.position) * CFrame.Angles(math.pi / 2, 0, 0), paint, {
radius = 12,
duration = 0.35,
})
end
-- Barrage ticks fire constantly; a full shake on each would be nauseating.
local magnitude = if heavy then 1.6 elseif payload.tick then 0.18 else 0.5
shakeFrom(payload.position, magnitude, if heavy then 0.4 else 0.16)
end
function HANDLERS.ChargeStart(payload)
clearRunning(payload.user)
local character = characterOf(payload.user)
if not character then
return
end
local paint = Palette.get(payload.characterId)
track(payload.user, Vfx.aura(character, paint, { rate = 70, converge = true, lightRange = 18 }))
-- Rings pulsing inward mark the wind-up.
local pulsing = true
track(payload.user, function()
pulsing = false
end)
task.spawn(function()
while pulsing do
local root = character:FindFirstChild("HumanoidRootPart")
if not root or not root:IsA("BasePart") then
break
end
Vfx.ring(CFrame.new(root.Position - Vector3.new(0, 2.5, 0)), paint, {
radius = 9,
duration = 0.5,
thickness = 0.5,
height = 0.8,
})
task.wait(0.35)
end
end)
end
function HANDLERS.ChargeRelease(payload)
clearRunning(payload.user)
local paint = Palette.get(payload.characterId)
local signature = SIGNATURE[payload.move]
if signature then
signature(payload, paint)
else
local root = rootOf(payload.user)
if root then
Vfx.ring(root.CFrame * CFrame.Angles(math.pi / 2, 0, 0), paint, { radius = 16, duration = 0.4 })
Vfx.burst(root.Position, paint, { count = 34, scale = 1.4 })
shakeFrom(root.Position, 1.4, 0.4)
end
end
end
function HANDLERS.ChargeCancel(payload)
clearRunning(payload.user)
end
function HANDLERS.CounterStance(payload)
clearRunning(payload.user)
local character = characterOf(payload.user)
if character then
track(payload.user, Vfx.aura(character, Palette.get(payload.characterId), { rate = 22, scale = 0.6 }))
end
end
function HANDLERS.Counter(payload)
clearRunning(payload.by)
local root = rootOf(payload.by)
if not root then
return
end
local paint = Palette.get(payload.characterId)
Vfx.flash(root.Position, Color3.fromRGB(255, 255, 255), 34, 0.25)
Vfx.burst(root.Position, paint, { count = 38, scale = 1.3 })
Vfx.ring(root.CFrame * CFrame.Angles(math.pi / 2, 0, 0), paint, { radius = 13, duration = 0.35 })
shakeFrom(root.Position, 2, 0.4)
end
function HANDLERS.CounterWhiff(payload)
clearRunning(payload.user)
end
function HANDLERS.Dash(payload)
local character = characterOf(payload.user)
if not character then
return
end
local paint = Palette.get(payload.characterId)
Vfx.afterimage(character, paint, { duration = 0.28 })
local root = character:FindFirstChild("HumanoidRootPart")
if root and root:IsA("BasePart") then
Vfx.burst(root.Position - Vector3.new(0, 2.4, 0), paint, { count = 10, scale = 0.6, light = false })
end
end
function HANDLERS.Teleport(payload)
local paint = Palette.get(payload.characterId)
local character = characterOf(payload.user)
if character then
Vfx.afterimage(character, paint, { duration = 0.4 })
end
if payload.from then
Vfx.burst(payload.from, paint, { count = 20, scale = 1 })
end
if payload.to then
Vfx.burst(payload.to, paint, { count = 20, scale = 1 })
end
end
function HANDLERS.Explode(payload)
if not payload.position then
return
end
local paint = Palette.get(payload.characterId)
Vfx.burst(payload.position, paint, { count = 26, scale = 1.3 })
Vfx.ring(CFrame.new(payload.position) * CFrame.Angles(math.pi / 2, 0, 0), paint, {
radius = 9,
duration = 0.3,
})
shakeFrom(payload.position, 0.6, 0.2)
end
function HANDLERS.Slam(payload)
if not payload.position then
return
end
local paint = Palette.get(payload.characterId)
Vfx.ring(CFrame.new(payload.position), paint, { radius = 16, duration = 0.4 })
Vfx.burst(payload.position, paint, { count = 30, scale = 1.4 })
shakeFrom(payload.position, 1.5, 0.35)
end
function HANDLERS.Sustain(payload)
-- The cone emitter is already running; this just adds a pulse of light.
if payload.position then
local paint = Palette.get(payload.characterId)
Vfx.flash(payload.position, paint.primary, 10, 0.12)
end
end
function HANDLERS.BlockBreak(payload)
local character = payload.target
if typeof(character) ~= "Instance" then
return
end
local root = character:FindFirstChild("HumanoidRootPart")
if not root or not root:IsA("BasePart") then
return
end
local white = { primary = Color3.fromRGB(255, 236, 180), secondary = Color3.fromRGB(255, 160, 90) }
white.texture = Palette.Texture.sparkle
white.style = "snap"
white.light = 16
Vfx.burst(root.Position, white, { count = 34, scale = 1.3 })
Vfx.ring(root.CFrame * CFrame.Angles(math.pi / 2, 0, 0), white, { radius = 11, duration = 0.35 })
shakeFrom(root.Position, 1.4, 0.35)
end
function HANDLERS.Burn(payload)
local target = payload.target
if typeof(target) ~= "Instance" then
return
end
local root = target:FindFirstChild("HumanoidRootPart")
if not root or not root:IsA("BasePart") then
return
end
-- One small puff per damage tick, so a burn reads as an ongoing thing
-- rather than a single hit.
Vfx.burst(root.Position + Vector3.new(0, 0.5, 0), Palette.get(payload.characterId), {
count = 6,
scale = 0.55,
light = false,
})
end
function HANDLERS.GrabWhiff(payload)
clearRunning(payload.user)
end
function HANDLERS.Blocked(payload)
local character = payload.target
if typeof(character) ~= "Instance" then
return
end
local root = character:FindFirstChild("HumanoidRootPart")
if root and root:IsA("BasePart") then
Vfx.flash(root.Position + Vector3.new(0, 1, 0), Color3.fromRGB(150, 200, 255), 10, 0.16)
end
end
--------------------------------------------------------------------------------
-- barrier bubble
--------------------------------------------------------------------------------
local function destroyBarrier(player)
local connection = barriers[player]
if connection then
connection:Disconnect()
barriers[player] = nil
end
end
function HANDLERS.BarrierUp(payload)
destroyBarrier(payload.user)
local character = characterOf(payload.user)
local root = if character then character:FindFirstChild("HumanoidRootPart") else nil
if not root or not root:IsA("BasePart") then
return
end
local paint = Palette.get(payload.characterId)
local shell = Instance.new("Part")
shell.Name = "BarrierShell"
shell.Shape = Enum.PartType.Ball
shell.Size = Vector3.new(11, 11, 11)
shell.Color = paint.primary
shell.Material = Enum.Material.ForceField
shell.Transparency = 0.35
shell.Anchored = true
shell.CanCollide = false
shell.CanQuery = false
shell.CanTouch = false
shell.CastShadow = false
shell.Parent = Workspace:FindFirstChild("ClientVfx") or Workspace
-- Anchored and re-placed each frame: welding a local part to a replicated
-- one gets jittery, and this stays exact.
local pulse = 0
barriers[payload.user] = RunService.RenderStepped:Connect(function(dt)
if not shell.Parent or not root.Parent then
destroyBarrier(payload.user)
shell:Destroy()
return
end
pulse += dt
local scale = 11 + math.sin(pulse * 5) * 0.4
shell.Size = Vector3.new(scale, scale, scale)
shell.CFrame = CFrame.new(root.Position)
end)
track(payload.user, function()
destroyBarrier(payload.user)
if shell.Parent then
TweenService:Create(shell, TweenInfo.new(0.25), { Transparency = 1 }):Play()
Debris:AddItem(shell, 0.3)
end
end)
end
function HANDLERS.BarrierHit(payload)
local root = rootOf(payload.user)
if root then
Vfx.flash(root.Position, Palette.get(payload.characterId).primary, 16, 0.18)
end
end
local function popBarrier(payload)
local root = rootOf(payload.user)
local paint = Palette.get(payload.characterId)
clearRunning(payload.user)
destroyBarrier(payload.user)
if root then
Vfx.dome(root.Position, paint, { radius = 14, duration = 0.35 })
Vfx.burst(root.Position, paint, { count = 30, scale = 1.2 })
shakeFrom(root.Position, 1.1, 0.3)
end
end
HANDLERS.BarrierPop = popBarrier
HANDLERS.BarrierDown = popBarrier
--------------------------------------------------------------------------------
function Effects.start()
Vfx.start()
Net.get("Effect").OnClientEvent:Connect(function(name, payload)
local handler = HANDLERS[name]
if not handler or typeof(payload) ~= "table" then
return
end
local ok, err = pcall(handler, payload)
if not ok then
warn(`[SBG] vfx handler {name} errored: {err}`)
end
end)
Players.PlayerRemoving:Connect(function(player)
clearRunning(player)
destroyBarrier(player)
end)
end
return Effects
]]>
-
Palette
-
Vfx
= 1 then
connection:Disconnect()
for _, part in parts do
part:Destroy()
end
end
end)
end
-- Expanding hollow-looking sphere. Used for implosions and barrier pops.
function Vfx.dome(position: Vector3, paint, opts)
opts = opts or {}
local radius = opts.radius or 16
local duration = opts.duration or 0.4
local ball = decor(Vector3.new(1, 1, 1), paint.primary)
ball.Shape = Enum.PartType.Ball
ball.Transparency = 0.45
ball.CFrame = CFrame.new(position)
ball.Parent = container()
tweenOut(ball, duration, {
Size = Vector3.new(radius, radius, radius) * 2,
Transparency = 1,
})
end
-- Column of light punching up out of the ground.
function Vfx.pillar(position: Vector3, paint, opts)
opts = opts or {}
local height = opts.height or 26
local width = opts.width or 4
local duration = opts.duration or 0.5
local part = decor(Vector3.new(width, 1, width), paint.primary)
part.Transparency = 0.25
part.CFrame = CFrame.new(position)
part.Parent = container()
TweenService
:Create(part, TweenInfo.new(duration * 0.35, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
Size = Vector3.new(width, height, width),
CFrame = CFrame.new(position + Vector3.new(0, height / 2, 0)),
})
:Play()
task.delay(duration * 0.35, function()
tweenOut(
part,
duration * 0.65,
{ Transparency = 1, Size = Vector3.new(width * 0.2, height, width * 0.2) }
)
end)
end
-- Straight lance of light. Grows from the caster along `direction`.
function Vfx.beam(origin: Vector3, direction: Vector3, paint, opts)
opts = opts or {}
local length = opts.length or 55
local width = opts.width or 5
local duration = opts.duration or 0.42
local unit = if direction.Magnitude > 0.01 then direction.Unit else Vector3.new(0, 0, -1)
local part = decor(Vector3.new(width, width, 1), paint.primary)
part.Transparency = 0.1
part.CFrame = CFrame.new(origin + unit * 2, origin + unit * 4)
part.Parent = container()
TweenService
:Create(part, TweenInfo.new(duration * 0.25, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = Vector3.new(width, width, length),
CFrame = CFrame.new(origin + unit * (length / 2), origin + unit * length),
})
:Play()
task.delay(duration * 0.25, function()
tweenOut(part, duration * 0.75, { Transparency = 1, Size = Vector3.new(0.4, 0.4, length) })
end)
Vfx.flash(origin + unit * 3, paint.primary, 22, 0.3)
end
-- Streak left behind a moving limb.
function Vfx.trail(character: Model, paint, opts)
opts = opts or {}
local limbName = opts.limb or "Right Arm"
local limb = character:FindFirstChild(limbName)
or character:FindFirstChild("RightHand")
or character:FindFirstChild("RightLowerArm")
if not limb or not limb:IsA("BasePart") then
return function() end
end
local a0 = Instance.new("Attachment")
a0.Position = Vector3.new(0, -0.9, 0)
a0.Parent = limb
local a1 = Instance.new("Attachment")
a1.Position = Vector3.new(0, 0.9, 0)
a1.Parent = limb
local trail = Instance.new("Trail")
trail.Attachment0 = a0
trail.Attachment1 = a1
trail.Color = ColorSequence.new(paint.primary, paint.secondary)
trail.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0.15),
NumberSequenceKeypoint.new(1, 1),
})
trail.Lifetime = opts.lifetime or 0.28
trail.LightEmission = 1
trail.LightInfluence = 0
trail.FaceCamera = true
trail.Parent = limb
local stopped = false
return function()
if stopped then
return
end
stopped = true
trail.Enabled = false
Debris:AddItem(trail, 0.5)
Debris:AddItem(a0, 0.5)
Debris:AddItem(a1, 0.5)
end
end
function Vfx.flash(position: Vector3, color: Color3, range: number, duration: number)
local anchor = decor(Vector3.new(0.2, 0.2, 0.2), color)
anchor.Transparency = 1
anchor.CFrame = CFrame.new(position)
anchor.Parent = container()
local light = Instance.new("PointLight")
light.Color = color
light.Range = range
light.Brightness = 5
light.Parent = anchor
tweenOut(light, duration, { Brightness = 0, Range = range * 0.3 })
Debris:AddItem(anchor, duration + 0.15)
end
-- Ghost copy of a character that fades in place. Used by teleports and dashes.
function Vfx.afterimage(character: Model, paint, opts)
opts = opts or {}
local duration = opts.duration or 0.35
local parent = container()
for _, part in character:GetChildren() do
if not part:IsA("BasePart") or part.Transparency >= 1 then
continue
end
local ghost = part:Clone()
ghost:ClearAllChildren()
ghost.Anchored = true
ghost.CanCollide = false
ghost.CanQuery = false
ghost.CanTouch = false
ghost.CastShadow = false
ghost.Material = Enum.Material.Neon
ghost.Color = paint.primary
ghost.Transparency = 0.55
ghost.Parent = parent
tweenOut(ghost, duration, { Transparency = 1 })
end
end
--------------------------------------------------------------------------------
-- camera shake
--------------------------------------------------------------------------------
local shakes: { { magnitude: number, remaining: number, duration: number } } = {}
function Vfx.shake(magnitude: number, duration: number)
table.insert(shakes, { magnitude = magnitude, remaining = duration, duration = duration })
end
local function updateShake(dt: number)
if #shakes == 0 then
return
end
local camera = Workspace.CurrentCamera
if not camera then
table.clear(shakes)
return
end
local total = 0
for index = #shakes, 1, -1 do
local entry = shakes[index]
entry.remaining -= dt
if entry.remaining <= 0 then
table.remove(shakes, index)
else
-- Falls off over the life of the shake so it settles instead of
-- cutting out.
total += entry.magnitude * (entry.remaining / entry.duration)
end
end
if total <= 0 then
return
end
total = math.min(total, 3)
local offset = Vector3.new(
(math.random() - 0.5) * total,
(math.random() - 0.5) * total,
(math.random() - 0.5) * total * 0.4
)
camera.CFrame = camera.CFrame
* CFrame.new(offset)
* CFrame.Angles(0, 0, (math.random() - 0.5) * total * 0.02)
end
function Vfx.start()
-- After the camera has been positioned for this frame, so the offset is not
-- immediately overwritten.
RunService:BindToRenderStep("SBGShake", Enum.RenderPriority.Camera.Value + 1, updateShake)
end
return Vfx
]]>
-
PowerController
server, and server state -> HUD. Holds no authority; it only
-- smooths the 12 Hz snapshot into something that ticks every frame.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Shared = ReplicatedStorage:WaitForChild("Shared")
local Powers = require(Shared.Powers)
local Net = require(Shared.Net)
local UI = require(script.Parent.UI)
local DamageNumbers = require(script.Parent.UI.DamageNumbers)
local Animation = require(script.Parent.Animation)
local Effects = require(script.Parent.Effects)
local Universal = Powers.Universal
local LocalPlayer = Players.LocalPlayer
local PowerController = {}
local SLOT_KEYS = {
[Enum.KeyCode.One] = 1,
[Enum.KeyCode.Two] = 2,
[Enum.KeyCode.Three] = 3,
[Enum.KeyCode.Four] = 4,
}
local state = {
characterId = Powers.DefaultCharacter,
snapshot = nil,
snapshotAt = 0,
}
local hud
local function send(action: string, payload)
Net.get("Action"):FireServer(action, payload)
end
--------------------------------------------------------------------------------
-- snapshot smoothing
--------------------------------------------------------------------------------
-- Timers arrive as remaining-seconds at snapshot time, so subtracting the age
-- of the snapshot gives a countdown that ticks every frame instead of 12/sec.
local function derive()
local snapshot = state.snapshot
if not snapshot then
return nil
end
local age = os.clock() - state.snapshotAt
local cooldowns = {}
for id, remaining in snapshot.cooldowns do
cooldowns[id] = math.max(0, remaining - age)
end
local charging = nil
if snapshot.charging then
local move = Powers.getMove(snapshot.characterId, snapshot.charging.moveId)
local ratio = snapshot.charging.ratio
if move and move.charge then
ratio = math.clamp(ratio + age / math.max(move.charge.max - move.charge.min, 0.001), 0, 1)
end
charging = { moveId = snapshot.charging.moveId, ratio = ratio }
end
return {
characterId = snapshot.characterId,
health = snapshot.health,
maxHealth = snapshot.maxHealth,
block = snapshot.block,
stamina = snapshot.stamina,
dash = snapshot.dash,
cooldowns = cooldowns,
stun = math.max(0, snapshot.stun - age),
ragdoll = math.max(0, snapshot.ragdoll - age),
busy = snapshot.busy,
charging = charging,
barrier = snapshot.barrier,
}
end
--------------------------------------------------------------------------------
-- input
--------------------------------------------------------------------------------
local function dashDirection(): Vector3
local character = LocalPlayer.Character
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if humanoid and humanoid.MoveDirection.Magnitude > 0.1 then
return humanoid.MoveDirection
end
local camera = workspace.CurrentCamera
if camera then
local look = camera.CFrame.LookVector
return Vector3.new(look.X, 0, look.Z)
end
return Vector3.zero
end
local function isRagdolled(): boolean
local derived = derive()
return derived ~= nil and derived.ragdoll > 0
end
local function onInputBegan(input: InputObject, gameProcessed: boolean)
if input.KeyCode == Enum.KeyCode.Tab and not gameProcessed then
hud:toggleRoster()
return
end
if gameProcessed or hud:isRosterOpen() then
return
end
local slot = SLOT_KEYS[input.KeyCode]
if slot then
send("Move", { slot = slot })
hud:flashSlot(slot)
return
end
if input.UserInputType == Enum.UserInputType.MouseButton1 then
send("M1", nil)
elseif input.KeyCode == Universal.Block.bind then
send("Block", { holding = true })
elseif input.KeyCode == Universal.Dash.bind then
send("Dash", { direction = dashDirection() })
elseif input.KeyCode == Universal.Sprint.bind then
send("Sprint", { holding = true })
elseif input.KeyCode == Universal.Getup.bind and isRagdolled() then
send("Getup", nil)
end
end
local function onInputEnded(input: InputObject, gameProcessed: boolean)
if gameProcessed then
return
end
local slot = SLOT_KEYS[input.KeyCode]
if slot then
-- Charge moves fire on release; everything else ignores this.
send("MoveRelease", { slot = slot })
return
end
if input.KeyCode == Universal.Block.bind then
send("Block", { holding = false })
elseif input.KeyCode == Universal.Sprint.bind then
send("Sprint", { holding = false })
end
end
--------------------------------------------------------------------------------
-- cosmetic events
--------------------------------------------------------------------------------
local EFFECTS = {}
--------------------------------------------------------------------------------
-- animation
--
-- Every client plays every character's clips locally off these broadcasts, so
-- nothing about the pose has to replicate.
--------------------------------------------------------------------------------
local function characterOf(player): Model?
return if typeof(player) == "Instance" and player:IsA("Player") then player.Character else nil
end
local function playMove(payload)
Animation.play(characterOf(payload.user), payload.animation, {
duration = payload.duration,
mirror = payload.mirror,
})
end
EFFECTS.MoveStart = playMove
EFFECTS.ChargeRelease = playMove
function EFFECTS.ChargeStart(payload)
Animation.play(characterOf(payload.user), payload.animation)
end
function EFFECTS.CounterStance(payload)
Animation.play(characterOf(payload.user), payload.animation)
end
function EFFECTS.BarrierUp(payload)
Animation.play(characterOf(payload.user), payload.animation)
end
function EFFECTS.MoveEnd(payload)
Animation.stop(characterOf(payload.user))
end
function EFFECTS.ChargeCancel(payload)
Animation.stop(characterOf(payload.user))
end
function EFFECTS.BarrierDown(payload)
Animation.stop(characterOf(payload.user))
end
function EFFECTS.Damage(payload)
local mine = payload.source == LocalPlayer
if mine then
hud:showHitmarker()
end
if payload.target == LocalPlayer.Character then
hud:showDamage()
end
-- Show the number for anything you dealt, and for anything dealt to you.
if payload.target and (mine or payload.target == LocalPlayer.Character) then
DamageNumbers.show(payload.target, payload.amount or 0, mine)
end
end
function EFFECTS.Counter(payload)
if payload.by == LocalPlayer then
hud:showBanner("counter!", Color3.fromRGB(120, 220, 200))
elseif payload.against == LocalPlayer then
hud:showBanner("countered", Color3.fromRGB(228, 74, 70))
hud:showDamage()
end
end
function EFFECTS.BlockBreak(payload)
if payload.target == LocalPlayer.Character then
hud:showBanner("guard broken", Color3.fromRGB(255, 108, 78))
hud:showDamage()
end
end
function EFFECTS.BarrierPop(payload)
if payload.user == LocalPlayer then
hud:showBanner("barrier shattered", Color3.fromRGB(180, 128, 232))
end
end
function EFFECTS.Dodge(payload)
if payload.target == LocalPlayer.Character then
hud:showBanner("dodged", Color3.fromRGB(140, 148, 167))
end
end
--------------------------------------------------------------------------------
function PowerController.start()
Animation.start()
Effects.start()
hud = UI.new(function(characterId)
state.characterId = characterId
hud:setCharacter(characterId)
Net.get("SelectCharacter"):FireServer(characterId)
end)
hud:setCharacter(state.characterId)
Net.get("State").OnClientEvent:Connect(function(snapshot)
if snapshot.characterId ~= state.characterId then
state.characterId = snapshot.characterId
hud:setCharacter(snapshot.characterId)
end
state.snapshot = snapshot
state.snapshotAt = os.clock()
end)
Net.get("Effect").OnClientEvent:Connect(function(name, payload)
local handler = EFFECTS[name]
if handler and payload then
handler(payload)
end
end)
UserInputService.InputBegan:Connect(onInputBegan)
UserInputService.InputEnded:Connect(onInputEnded)
RunService.RenderStepped:Connect(function()
local derived = derive()
if derived then
hud:update(derived)
end
end)
end
return PowerController
]]>
-
UI
-
CharacterSelect
-
Create
-
DamageNumbers
= 30 then 30 else 21,
TextStrokeTransparency = 0.35,
})
local billboard = Create("BillboardGui", {
Name = "DamageNumber",
Size = UDim2.fromOffset(90, 40),
StudsOffsetWorldSpace = drift,
AlwaysOnTop = true,
MaxDistance = 250,
label,
Parent = head,
})
Debris:AddItem(billboard, LIFETIME + 0.1)
local info = TweenInfo.new(LIFETIME, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
TweenService:Create(billboard, info, {
StudsOffsetWorldSpace = drift + Vector3.new(0, 3.4, 0),
}):Play()
TweenService:Create(label, info, {
TextTransparency = 1,
TextStrokeTransparency = 1,
}):Play()
end
return DamageNumbers
]]>
-
Meters
= 1
then "MAX CHARGE — RELEASE"
else `CHARGING {math.floor(state.charging.ratio * 100)}%`
else
self.chargeBar.Visible = false
end
-- knockdown / stun
self.getupLabel.Visible = (state.ragdoll or 0) > 0
self.stunLabel.Visible = (state.ragdoll or 0) <= 0 and (state.stun or 0) > 0
end
return Meters
]]>
-
MoveBar
= 10 then
return tostring(math.ceil(seconds))
end
return string.format("%.1f", seconds)
end
function MoveBar.update(self, state)
for index = 1, 4 do
local slot = self.slots[index]
local move = slot.move
if not move then
continue
end
local remaining = (state.cooldowns and state.cooldowns[move.id]) or 0
local ratio = if move.cooldown > 0 then math.clamp(remaining / move.cooldown, 0, 1) else 0
slot.fill.Size = UDim2.fromScale(1, ratio)
slot.text.Text = formatCooldown(remaining)
slot.name.TextColor3 = if remaining > 0 then Theme.cooling else Theme.ready
slot.key.TextColor3 = if remaining > 0 then Theme.textFaint else Theme.textDim
-- Highlight whichever move is mid-charge.
local isCharging = state.charging ~= nil and state.charging.moveId == move.id
if isCharging then
slot.stroke.Color = Theme.charge
slot.stroke.Thickness = 2 + state.charging.ratio * 2
elseif move.ultimate then
slot.stroke.Color = Theme.ultimate
slot.stroke.Thickness = 2
else
slot.stroke.Color = if remaining > 0 then Theme.stroke else Theme.strokeHot
slot.stroke.Thickness = 1.5
end
end
-- Block pill reflects meter state.
local blockPill = self.pills.Block
if state.block then
if state.block.broken then
blockPill.stroke.Color = Theme.blockBroken
blockPill.label.TextColor3 = Theme.blockBroken
blockPill.label.Text = "BROKEN"
else
blockPill.stroke.Color = if state.block.holding then Theme.block else Theme.stroke
blockPill.label.TextColor3 = if state.block.holding then Theme.block else Theme.textDim
blockPill.label.Text = string.upper(Universal.Block.name)
end
end
-- Dash pips.
if state.dash then
local dashPill = self.pills.Dash
for i, pip in dashPill.pipParts do
local filled = i <= state.dash.count
pip.BackgroundColor3 = if filled then Theme.stamina else Theme.panelRaised
pip.BackgroundTransparency = if filled then 0 else 0.25
end
dashPill.stroke.Color = if state.dash.count > 0 then Theme.stroke else Theme.textFaint
end
-- Sprint pill dims when stamina is gone.
local sprintPill = self.pills.Sprint
if state.stamina then
local empty = state.stamina.value <= 1
sprintPill.label.TextColor3 = if empty then Theme.textFaint else Theme.textDim
end
end
-- Quick pop when a move fires, so inputs feel acknowledged even on lag.
function MoveBar.flash(self, slotIndex: number)
local slot = self.slots[slotIndex]
if not slot then
return
end
local original = UDim2.fromOffset(Theme.slotSize, Theme.slotSize)
slot.frame.Size = UDim2.fromOffset(Theme.slotSize + 6, Theme.slotSize + 6)
TweenService:Create(slot.frame, TweenInfo.new(0.16, Enum.EasingStyle.Quad), { Size = original }):Play()
end
return MoveBar
]]>
-
Theme