- ReplicatedFirst
- LoadingScreen= 100 then
while (not game:IsLoaded() or os.clock() - t0 < 6.5) do
task.wait(0.2)
end
end
end
done = true
stage.Text = "THE BLADE IS DRAWN · 準備完了"
tw(ready, TweenInfo.new(1), { TextTransparency = 0.2 })
task.spawn(function()
while done and gui.Parent do
tw(ready, TweenInfo.new(0.9), { TextTransparency = 0.65 })
task.wait(0.95)
tw(ready, TweenInfo.new(0.9), { TextTransparency = 0.1 })
task.wait(0.95)
end
end)
end)
local hb
hb = RunService.RenderStepped:Connect(function(dt)
shown = shown + (progress - shown) * math.min(1, dt * 4)
pct.Text = ("%d %%"):format(math.floor(shown))
bladeClip.Size = UDim2.new(0, math.floor(540 * shown / 100), 0, 10)
bladeGrad.Offset = Vector2.new((os.clock() * 0.4) % 1.5 - 0.75, 0)
if not done then
local idx = math.min(#STAGES, math.floor(shown / 100 * #STAGES) + 1)
stage.Text = STAGES[idx][1] .. " · " .. STAGES[idx][2]
end
end)
-- ------------------------------------------------------------- katana-cut exit
local exiting = false
local function exit()
if exiting or not done then return end
exiting = true
local shing = make("Sound", {
SoundId = "rbxasset://sounds/unsheath.wav", Volume = 1, PlaybackSpeed = 1.2, Parent = gui,
})
shing:Play()
-- white slash flash
local flash = make("Frame", {
AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 0, 0.5, 0),
Size = UDim2.new(2, 0, 0, 6), Rotation = -14,
BackgroundColor3 = Color3.new(1, 1, 1), BorderSizePixel = 0, Parent = gui,
})
tw(flash, TweenInfo.new(0.12, Enum.EasingStyle.Quad), { Size = UDim2.new(2, 0, 0, 90), BackgroundTransparency = 0.2 })
task.delay(0.12, function()
tw(flash, TweenInfo.new(0.3), { BackgroundTransparency = 1 })
end)
-- two halves fly apart
rootFrame.BackgroundTransparency = 1
local top = make("Frame", {
AnchorPoint = Vector2.new(0.5, 1), Position = UDim2.new(0.5, 0, 0.52, 0),
Size = UDim2.new(2.2, 0, 1.2, 0), Rotation = -14,
BackgroundColor3 = LACQUER, BorderSizePixel = 0, ZIndex = 0, Parent = gui,
})
local bottom = make("Frame", {
AnchorPoint = Vector2.new(0.5, 0), Position = UDim2.new(0.5, 0, 0.52, 0),
Size = UDim2.new(2.2, 0, 1.2, 0), Rotation = -14,
BackgroundColor3 = LACQUER, BorderSizePixel = 0, ZIndex = 0, Parent = gui,
})
-- hide the composed content instantly; the halves now represent the screen
for _, child in ipairs(rootFrame:GetChildren()) do
if child:IsA("GuiObject") then
child.Visible = false
end
end
local cutInfo = TweenInfo.new(0.9, Enum.EasingStyle.Quart, Enum.EasingDirection.In)
tw(top, cutInfo, { Position = UDim2.new(0.62, 0, -0.9, 0), Rotation = -11 })
tw(bottom, cutInfo, { Position = UDim2.new(0.38, 0, 1.94, 0), Rotation = -17 })
task.delay(1.1, function()
hb:Disconnect()
gui:Destroy()
end)
end
UserInputService.InputBegan:Connect(function(input)
if input.UserInputType == Enum.UserInputType.Keyboard
or input.UserInputType == Enum.UserInputType.MouseButton1
or input.UserInputType == Enum.UserInputType.Touch
or input.UserInputType == Enum.UserInputType.Gamepad1 then
exit()
end
end)
]]>
- ReplicatedStorage
- Shared
- AnimPoses
- Config
- KatanaBuilder
- Net Server) combat intents { a = "light" | "heavy_start" | ... }
Combat (Server -> All) combat presentation events (drives anims/VFX/SFX everywhere)
State (Server -> Player) own vitals { hp, po, st, ult, stance }
Weather (Server -> All) { index = n } current weather preset
Announce (Server -> All/1) { kanji, text, dur }
KillFeed (Server -> All) { killer, victim, executed }
Actors (Server -> All) actor registry sync { id, model, name } / { id, gone = true }
]]
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local REMOTE_NAMES = { "Action", "Combat", "State", "Weather", "Announce", "KillFeed", "Actors" }
local Net = {}
local function getFolder()
if RunService:IsServer() then
local folder = ReplicatedStorage:FindFirstChild("TLS_Remotes")
if not folder then
folder = Instance.new("Folder")
folder.Name = "TLS_Remotes"
folder.Parent = ReplicatedStorage
end
return folder
end
return ReplicatedStorage:WaitForChild("TLS_Remotes")
end
function Net.get()
local folder = getFolder()
local remotes = {}
for _, name in ipairs(REMOTE_NAMES) do
if RunService:IsServer() then
local r = folder:FindFirstChild(name)
if not r then
r = Instance.new("RemoteEvent")
r.Name = name
r.Parent = folder
end
remotes[name] = r
else
remotes[name] = folder:WaitForChild(name)
end
end
return remotes
end
return Net
]]>
- Sounds
- Util hi then return hi end
return v
end
function Util.ease(t)
if t < 0.5 then
return 2 * t * t
end
return 1 - math.pow(-2 * t + 2, 2) / 2
end
-- ---------- instance builder ----------
-- Util.make("Part", { Name = "X", Parent = ..., Size = ... , Children = {...} })
function Util.make(className, props)
local inst = Instance.new(className)
local parent = nil
for k, v in pairs(props or {}) do
if k == "Parent" then
parent = v
elseif k == "Children" then
for _, child in ipairs(v) do
child.Parent = inst
end
else
inst[k] = v
end
end
if parent then
inst.Parent = parent
end
return inst
end
-- ---------- misc ----------
function Util.flatDirection(v)
local flat = Vector3.new(v.X, 0, v.Z)
if flat.Magnitude < 0.001 then
return Vector3.new(0, 0, -1)
end
return flat.Unit
end
function Util.yawCFrame(position, lookAt)
local dir = Util.flatDirection(lookAt - position)
return CFrame.lookAt(position, position + dir)
end
function Util.retry(times, delaySeconds, fn, ...)
local lastErr
for _ = 1, times do
local ok, res = pcall(fn, ...)
if ok then
return true, res
end
lastErr = res
task.wait(delaySeconds)
end
return false, lastErr
end
return Util
]]>
- ServerScriptService
- Server data -> combat -> world -> weather -> AI -> anticheat.
]]
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Shared = ReplicatedStorage:WaitForChild("Shared")
local Net = require(Shared:WaitForChild("Net"))
local Config = require(Shared:WaitForChild("Config"))
local DataService = require(script:WaitForChild("DataService"))
local CombatService = require(script:WaitForChild("CombatService"))
local MapService = require(script:WaitForChild("MapService"))
local WeatherService = require(script:WaitForChild("WeatherService"))
local AIService = require(script:WaitForChild("AIService"))
local AntiCheat = require(script:WaitForChild("AntiCheat"))
local remotes = Net.get()
Players.RespawnTime = Config.Combat.RespawnTime
DataService.init()
CombatService.init(remotes, DataService)
MapService.build()
WeatherService.init(remotes, CombatService)
AIService.init(remotes, CombatService, MapService)
AntiCheat.init()
-- kill rewards
CombatService.ActorDied:Connect(function(victimId, killerId, executed)
if killerId and killerId > 0 then
local killer = Players:GetPlayerByUserId(killerId)
if killer then
local mult = WeatherService.isBloodMoon() and 2 or 1
DataService.award(killer, {
coins = Config.Rewards.KillCoins * mult,
xp = Config.Rewards.KillXP * mult,
kills = 1,
})
end
end
end)
-- level-up fanfare
DataService.onLevelUp = function(player, newLevel)
remotes.Announce:FireClient(player, {
kanji = "昇段", text = ("LEVEL %d"):format(newLevel), dur = 3,
})
end
-- keep the AI's fog handicap in sync with the weather
task.spawn(function()
while true do
AIService.setWeatherIndex(WeatherService.Index)
task.wait(2)
end
end)
-- simple chat commands: /weather cycles presets
Players.PlayerAdded:Connect(function(player)
player.Chatted:Connect(function(msg)
if msg:lower() == "/weather" then
WeatherService.next()
end
end)
end)
print("[THE LAST SAMURAI] server ready — 始め!")
]]>
- AIService brain
local INK = Color3.fromRGB(24, 19, 26)
local SKIN = Color3.fromRGB(216, 176, 141)
local STRAW = Color3.fromRGB(178, 152, 96)
local CRIMSON = Color3.fromRGB(140, 47, 57)
-- ------------------------------------------------------------- rig builder
local function limb(name, size, color, parent)
return Util.make("Part", {
Name = name, Size = size, Color = color,
Material = Enum.Material.Fabric,
Anchored = false, CanCollide = false,
TopSurface = Enum.SurfaceType.Smooth, BottomSurface = Enum.SurfaceType.Smooth,
Parent = parent,
})
end
local function motor(name, p0, p1, c0, c1)
return Util.make("Motor6D", { Name = name, Part0 = p0, Part1 = p1, C0 = c0, C1 = c1, Parent = p0 })
end
function AIService.buildRig(name, cframe)
local model = Instance.new("Model")
model.Name = name
local hrp = Util.make("Part", {
Name = "HumanoidRootPart", Size = Vector3.new(2, 2, 1),
Transparency = 1, Anchored = false, CanCollide = true,
Parent = model,
})
local torso = limb("Torso", Vector3.new(2, 2, 1), INK, model)
local head = limb("Head", Vector3.new(2, 1, 1), SKIN, model)
Util.make("SpecialMesh", { MeshType = Enum.MeshType.Head, Scale = Vector3.new(1.25, 1.25, 1.25), Parent = head })
local ra = limb("Right Arm", Vector3.new(1, 2, 1), INK, model)
local la = limb("Left Arm", Vector3.new(1, 2, 1), INK, model)
local rl = limb("Right Leg", Vector3.new(1, 2, 1), INK, model)
local ll = limb("Left Leg", Vector3.new(1, 2, 1), INK, model)
-- canonical R6 joints (identical to a real player rig)
local ang = CFrame.Angles
motor("RootJoint", hrp, torso,
CFrame.new(0, 0, 0) * ang(-math.pi / 2, 0, math.pi),
CFrame.new(0, 0, 0) * ang(-math.pi / 2, 0, math.pi))
motor("Neck", torso, head,
CFrame.new(0, 1, 0) * ang(-math.pi / 2, 0, math.pi),
CFrame.new(0, -0.5, 0) * ang(-math.pi / 2, 0, math.pi))
motor("Right Shoulder", torso, ra,
CFrame.new(1, 0.5, 0) * ang(0, math.pi / 2, 0),
CFrame.new(-0.5, 0.5, 0) * ang(0, math.pi / 2, 0))
motor("Left Shoulder", torso, la,
CFrame.new(-1, 0.5, 0) * ang(0, -math.pi / 2, 0),
CFrame.new(0.5, 0.5, 0) * ang(0, -math.pi / 2, 0))
motor("Right Hip", torso, rl,
CFrame.new(1, -1, 0) * ang(0, math.pi / 2, 0),
CFrame.new(0.5, 1, 0) * ang(0, math.pi / 2, 0))
motor("Left Hip", torso, ll,
CFrame.new(-1, -1, 0) * ang(0, -math.pi / 2, 0),
CFrame.new(-0.5, 1, 0) * ang(0, -math.pi / 2, 0))
-- crimson obi sash
local sash = limb("Sash", Vector3.new(2.06, 0.5, 1.06), CRIMSON, model)
Util.make("WeldConstraint", { Part0 = torso, Part1 = sash, Parent = sash })
sash.CFrame = torso.CFrame * CFrame.new(0, -0.55, 0)
-- kasa (straw hat): three shrinking discs
local hatSizes = { { 4.4, 0.3 }, { 3.2, 0.35 }, { 1.9, 0.4 } }
for i, hs in ipairs(hatSizes) do
local disc = Util.make("Part", {
Name = "Kasa" .. i, Shape = Enum.PartType.Cylinder,
Size = Vector3.new(hs[2], hs[1], hs[1]),
Color = STRAW, Material = Enum.Material.Fabric,
Anchored = false, CanCollide = false, Massless = true,
Parent = model,
})
Util.make("WeldConstraint", { Part0 = head, Part1 = disc, Parent = disc })
disc.CFrame = head.CFrame * CFrame.new(0, 0.42 + i * 0.22, 0) * CFrame.Angles(0, 0, math.rad(90))
end
local humanoid = Util.make("Humanoid", {
RigType = Enum.HumanoidRigType.R6,
Parent = model,
})
humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.None
model.PrimaryPart = hrp
model:PivotTo(cframe)
model.Parent = Workspace
return model
end
-- ------------------------------------------------------------- brains
local function newBrain(actorId, spec, home)
return {
id = actorId, spec = spec, home = home,
target = nil, nextThink = 0, nextAttack = 0,
comboLeft = 0, blockRelease = 0, reactUntil = 0,
}
end
local function findTarget(brain, actor)
local best, bestDist = nil, brain.spec.engageRange or 60
for id, other in pairs(combatService.Actors) do
if id ~= brain.id and not other.dead and not other.isNPC and other.root then
local d = (other.root.Position - actor.root.Position).Magnitude
if d < bestDist then
best, bestDist = other, d
end
end
end
return best
end
local function think(brain, actor, t)
local spec = brain.spec
if spec.aggro <= 0 then
return -- training dummy: stands there, takes it, teaches nothing but truth
end
local target = brain.target
if not target or target.dead or not target.root
or (target.root.Position - actor.root.Position).Magnitude > spec.engageRange * 1.6 then
brain.target = findTarget(brain, actor)
target = brain.target
end
local humanoid = actor.humanoid
if not target then
-- patrol near home
if math.random() < 0.3 then
humanoid:MoveTo(brain.home + Vector3.new(math.random(-14, 14), 0, math.random(-14, 14)))
end
return
end
local myPos = actor.root.Position
local dist = (target.root.Position - myPos).Magnitude
-- release a held block
if actor.blocking and t > brain.blockRelease then
combatService.DoAction(brain.id, { a = "block", on = false })
end
-- low stamina: give ground
if actor.stamina < 20 then
local away = Util.flatDirection(myPos - target.root.Position)
humanoid:MoveTo(myPos + away * 14)
return
end
-- execution opportunity
if (t < target.gbUntil or target.hp <= Config.Combat.ExecuteHPThreshold)
and dist < Config.Combat.ExecuteRange - 2 and math.random() < 0.6 then
combatService.DoAction(brain.id, { a = "execute" })
return
end
if dist > 9 then
-- close in; occasional dash approach
humanoid:MoveTo(target.root.Position)
if dist > 16 and dist < 34 and math.random() < 0.12 then
combatService.DoAction(brain.id, { a = "dash", dir = Util.flatDirection(target.root.Position - myPos) })
task.delay(0.25, function()
if not actor.dead then
combatService.DoAction(brain.id, { a = "dash_attack" })
end
end)
end
else
-- in range: strafe a little, pick fights
if math.random() < 0.35 then
local right = actor.root.CFrame.RightVector
humanoid:MoveTo(myPos + right * (math.random() < 0.5 and 6 or -6))
end
if t >= brain.nextAttack and not actor.blocking then
if target.blockStreak >= 3 and math.random() < 0.7 then
combatService.DoAction(brain.id, { a = "heavy_start" })
task.delay(0.45 + math.random() * 0.4, function()
if not actor.dead then
combatService.DoAction(brain.id, { a = "heavy_release" })
end
end)
brain.nextAttack = t + 2
elseif math.random() < spec.aggro then
brain.comboLeft = math.random(1, spec.comboMax)
combatService.DoAction(brain.id, { a = "light" })
brain.comboLeft = brain.comboLeft - 1
brain.nextAttack = t + 0.55
else
brain.nextAttack = t + 0.35
end
elseif brain.comboLeft > 0 and actor.attack == nil and t >= actor.busyUntil then
combatService.DoAction(brain.id, { a = "light" })
brain.comboLeft = brain.comboLeft - 1
brain.nextAttack = t + 0.55
end
end
end
-- react to enemy windups with a human delay
local function onAttackStarted(attackerId, key, windup)
local attacker = combatService.getActor(attackerId)
if not attacker then return end
for id, brain in pairs(brains) do
local actor = combatService.getActor(id)
local spec = brain.spec
if actor and not actor.dead and spec.aggro > 0 and brain.target == attacker then
local t = os.clock()
if t < brain.reactUntil then
return
end
local dist = (attacker.root.Position - actor.root.Position).Magnitude
local atkCfg = Config.Attacks[key]
if atkCfg and dist < atkCfg.range + 6 then
brain.reactUntil = t + spec.reaction * (1 + math.random())
local roll = math.random()
local fogged = false
-- Ghost Fog dulls AI eyes (weather index 5)
if AIService.WeatherIndex == 5 then
fogged = math.random() < 0.4
end
if not fogged and roll < spec.parryChance then
-- time the block so it lands inside the parry window
local delay = math.max(0, windup - Config.Combat.ParryWindow * 0.5
- spec.reaction * 0.3 * math.random())
task.delay(delay, function()
if not actor.dead then
combatService.DoAction(id, { a = "block", on = true })
brain.blockRelease = os.clock() + 0.35
end
end)
elseif not fogged and roll < spec.parryChance + spec.blockChance then
task.delay(spec.reaction * math.random(), function()
if not actor.dead then
combatService.DoAction(id, { a = "block", on = true })
brain.blockRelease = os.clock() + 0.4 + math.random() * 0.4
end
end)
elseif roll > 0.85 then
combatService.DoAction(id, { a = "dash",
dir = Util.flatDirection(actor.root.Position - attacker.root.Position) })
end
end
end
end
end
-- ------------------------------------------------------------- spawning
local function spawnNPC(spec, position, displayName, isDummy)
local model = AIService.buildRig(displayName, CFrame.new(position))
local id = combatService.registerActor(model, {
npcName = displayName,
hp = spec.hp,
})
if not id then
model:Destroy()
return
end
local brain = newBrain(id, spec, position)
brain.isDummy = isDummy
brains[id] = brain
return id
end
local function respawnLater(brain, oldModel, name, spec)
task.delay(3.5, function()
if oldModel then
oldModel:Destroy()
end
end)
task.delay(brain.isDummy and 2.5 or 7, function()
spawnNPC(spec, brain.home, name, brain.isDummy)
end)
end
function AIService.init(remoteTable, combat, mapService)
combatService = combat
AIService.WeatherIndex = 1
combat.AttackStarted:Connect(onAttackStarted)
combat.ActorDied:Connect(function(victimId)
local brain = brains[victimId]
if brain then
brains[victimId] = nil
local actor = combat.getActor(victimId)
local model = actor and actor.model or nil
local name = actor and actor.npcName or "浪人 Ronin"
combat.unregister(victimId)
respawnLater(brain, model, name, brain.spec)
end
end)
-- dojo dummies
for i, pos in ipairs(mapService.DummySpots or {}) do
spawnNPC(Config.AI.Dummy, pos, "木人 Training Dummy " .. i, true)
end
-- ronin duelists
for _, spot in ipairs(mapService.RoninSpots or {}) do
local spec = Config.AI.Ronin[spot.diff] or Config.AI.Ronin[2]
local nm = Config.AI.Names[math.random(#Config.AI.Names)]
spawnNPC(spec, spot.pos, nm[1] .. " " .. nm[2], false)
end
-- brain tick
RunService.Heartbeat:Connect(function()
local t = os.clock()
for id, brain in pairs(brains) do
if t >= brain.nextThink then
brain.nextThink = t + 0.15 + math.random() * 0.1
local actor = combatService.getActor(id)
if actor and not actor.dead and not actor.cine
and t >= actor.gbUntil and t >= actor.staggerUntil then
think(brain, actor, t)
end
end
end
end)
end
function AIService.setWeatherIndex(i)
AIService.WeatherIndex = i
end
return AIService
]]>
- AntiCheat { lastPos, strikes, lastCheck }
-- generous ceiling: sprint speed * stance bonus + dash burst + physics slack
local MAX_SPEED = Config.Combat.DashSpeed + Config.Combat.SprintSpeed * 1.3 + 20
function AntiCheat.init()
Players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function(character)
local root = character:WaitForChild("HumanoidRootPart", 10)
if root then
tracked[player] = { lastPos = root.Position, strikes = 0, lastCheck = os.clock() }
end
end)
end)
Players.PlayerRemoving:Connect(function(player)
tracked[player] = nil
end)
local accum = 0
RunService.Heartbeat:Connect(function(dt)
accum = accum + dt
if accum < 0.5 then return end
accum = 0
local t = os.clock()
for player, rec in pairs(tracked) do
local char = player.Character
local root = char and char:FindFirstChild("HumanoidRootPart")
if root then
local elapsed = t - rec.lastCheck
if elapsed > 0.1 then
local dist = (root.Position - rec.lastPos).Magnitude
local speed = dist / elapsed
if speed > MAX_SPEED then
rec.strikes = rec.strikes + 1
if rec.strikes >= 3 then
-- rubber-band
root.CFrame = CFrame.new(rec.lastPos + Vector3.new(0, 2, 0))
warn(("[TLS AntiCheat] %s speed violation (%.0f studs/s)"):format(player.Name, speed))
rec.strikes = 0
end
else
rec.strikes = math.max(0, rec.strikes - 1)
rec.lastPos = root.Position
end
rec.lastCheck = t
end
end
end
end)
end
return AntiCheat
]]>
- CombatService actor
CombatService.ActorDied = Util.Signal.new() -- (victimId, killerId, executed)
CombatService.AttackStarted = Util.Signal.new()-- (attackerId, key, windup)
local remotes
local nextNpcId = -1000
local bloodMoon = false
-- ------------------------------------------------------------------ helpers
local function now()
return os.clock()
end
local function broadcast(payload)
remotes.Combat:FireAllClients(payload)
end
local function stanceOf(actor)
return Config.Stances[actor.stance] or Config.Stances[3]
end
local function actorPos(actor)
return actor.root and actor.root.Position or Vector3.zero
end
local function actorLook(actor)
return actor.root and Util.flatDirection(actor.root.CFrame.LookVector) or Vector3.new(0, 0, -1)
end
local function canAct(actor)
local t = now()
return not actor.dead and not actor.cine
and t >= actor.staggerUntil and t >= actor.gbUntil
and t >= actor.hurtUntil and t >= actor.busyUntil
and not actor.charging
end
local function setWalkSpeed(actor)
if not actor.humanoid then return end
local stance = stanceOf(actor)
local speed = C.WalkSpeed * stance.speed
if actor.blocking then
speed = C.BlockWalkSpeed
elseif actor.sprinting then
speed = C.SprintSpeed * stance.speed
end
if actor.dead or actor.cine or now() < actor.gbUntil then
speed = 0
end
actor.humanoid.WalkSpeed = speed
end
local function mirrorHealth(actor)
if actor.humanoid and actor.humanoid.Health > 0 then
actor.humanoid.Health = math.max(actor.hp, 0.001)
end
end
-- ------------------------------------------------------------------ registry
function CombatService.registerActor(model, opts)
opts = opts or {}
local humanoid = model:FindFirstChildOfClass("Humanoid")
local root = model:FindFirstChild("HumanoidRootPart")
if not humanoid or not root then
return nil
end
local id
if opts.player then
id = opts.player.UserId
else
nextNpcId = nextNpcId - 1
id = nextNpcId
end
local maxHP = opts.hp or C.MaxHP
humanoid.MaxHealth = maxHP
humanoid.Health = maxHP
humanoid.BreakJointsOnDeath = false
local actor = {
id = id,
model = model,
humanoid = humanoid,
root = root,
player = opts.player,
isNPC = opts.player == nil,
npcName = opts.npcName,
maxHP = maxHP,
hp = maxHP,
posture = 0,
stamina = C.MaxStamina,
ult = 0,
stance = 3, -- Water
blocking = false, blockStart = 0, blockStreak = 0,
attack = nil, busyUntil = 0,
combo = { lastKey = nil, chainUntil = 0 },
charging = nil,
staggerUntil = 0, gbUntil = 0, hurtUntil = 0, iframesUntil = 0,
cds = { dash = 0 },
sprinting = false,
dead = false, cine = false,
lastPostureGain = 0,
stats = { parries = 0, maxCombo = 0, comboNow = 0 },
}
CombatService.Actors[id] = actor
setWalkSpeed(actor)
KatanaBuilder.attach(model)
humanoid.Died:Connect(function()
if not actor.dead then
CombatService.kill(actor, nil, false)
end
end)
remotes.Actors:FireAllClients({
id = id, model = model,
npc = actor.isNPC, npcName = opts.npcName,
})
return id, actor
end
function CombatService.unregister(id)
local actor = CombatService.Actors[id]
if actor then
CombatService.Actors[id] = nil
remotes.Actors:FireAllClients({ id = id, gone = true })
end
end
function CombatService.getActor(id)
return CombatService.Actors[id]
end
function CombatService.syncActorsTo(player)
for id, actor in pairs(CombatService.Actors) do
if actor.model and actor.model.Parent then
remotes.Actors:FireClient(player, {
id = id, model = actor.model,
npc = actor.isNPC, npcName = actor.npcName,
})
end
end
end
-- ------------------------------------------------------------------ damage core
local function postureDamage(victim, amount)
victim.posture = Util.clamp(victim.posture + amount, 0, C.MaxPosture)
victim.lastPostureGain = now()
if victim.posture >= C.MaxPosture and now() >= victim.gbUntil then
victim.gbUntil = now() + C.GuardBreakStun
victim.blocking = false
victim.attack = nil
victim.charging = nil
setWalkSpeed(victim)
broadcast({ e = "guardbreak", id = victim.id, pos = actorPos(victim) })
task.delay(C.GuardBreakStun, function()
if not victim.dead and victim.posture >= C.MaxPosture then
victim.posture = C.PostureAfterBreak
end
end)
end
end
function CombatService.kill(victim, killer, executed)
if victim.dead then return end
victim.dead = true
victim.blocking = false
victim.attack = nil
victim.hp = 0
setWalkSpeed(victim)
broadcast({
e = "death", id = victim.id,
kid = killer and killer.id or nil,
executed = executed or false,
pos = actorPos(victim),
})
remotes.KillFeed:FireAllClients({
killer = killer and (killer.player and killer.player.DisplayName or killer.npcName or "?") or nil,
victim = victim.player and victim.player.DisplayName or victim.npcName or "?",
executed = executed or false,
})
CombatService.ActorDied:Fire(victim.id, killer and killer.id or nil, executed or false)
if victim.humanoid then
victim.humanoid.Health = 0
end
if victim.player then
CombatService.unregister(victim.id)
end
end
local function applyHit(attacker, victim, atk, mult)
local t = now()
local aStance = stanceOf(attacker)
local vStance = stanceOf(victim)
local pos = actorPos(victim) + Vector3.new(0, 1.5, 0)
if t < victim.iframesUntil then
broadcast({ e = "evade", id = victim.id, pos = pos })
return
end
local toVictim = Util.flatDirection(actorPos(victim) - actorPos(attacker))
local victimFacingAttacker = actorLook(victim):Dot(-toVictim) > 0.1
local backstab = actorLook(victim):Dot(toVictim) > 0.35
-- BLOCK / PARRY -----------------------------------------------------
if victim.blocking and victimFacingAttacker then
local window = C.ParryWindow * vStance.parryWindow
if t - victim.blockStart <= window then
-- PERFECT PARRY
victim.posture = math.max(0, victim.posture - C.ParryPostureRefund)
victim.ult = math.min(C.MaxUlt, victim.ult + C.ParryUltGain)
victim.stats.parries = victim.stats.parries + 1
attacker.attack = nil
attacker.charging = nil
attacker.staggerUntil = t + C.StaggerDuration + 0.25
attacker.busyUntil = attacker.staggerUntil
postureDamage(attacker, C.ParryPostureToAttacker)
broadcast({ e = "parry", id = victim.id, aid = attacker.id, pos = pos })
if victim.player then
local DataService = CombatService.DataService
if DataService then
DataService.award(victim.player, { coins = Config.Rewards.ParryCoins })
end
end
return
end
-- normal block
local pDmg = atk.posture * aStance.posture * vStance.blockCost
victim.stamina = math.max(0, victim.stamina - C.BlockStaminaCost)
victim.hp = math.max(1, victim.hp - atk.damage * C.BlockChip)
victim.blockStreak = victim.blockStreak + 1
mirrorHealth(victim)
if atk.guardBreak then
postureDamage(victim, C.MaxPosture)
else
postureDamage(victim, pDmg)
end
broadcast({
e = "hit", id = attacker.id, tid = victim.id,
blocked = true, dmg = 0, pos = pos,
guardBreak = atk.guardBreak or false,
})
return
end
-- CLEAN HIT ----------------------------------------------------------
local dmg = atk.damage * aStance.damage * (mult or 1)
if backstab then
dmg = dmg * C.BackstabMult
end
if bloodMoon then
dmg = dmg * 1.1
end
victim.hp = victim.hp - dmg
victim.blockStreak = 0
victim.hurtUntil = t + C.HurtStun
postureDamage(victim, atk.posture * 0.45)
victim.ult = math.min(C.MaxUlt, victim.ult + C.HitUltGainVictim)
attacker.ult = math.min(C.MaxUlt, attacker.ult + C.HitUltGainAttacker)
attacker.stats.comboNow = attacker.stats.comboNow + 1
attacker.stats.maxCombo = math.max(attacker.stats.maxCombo, attacker.stats.comboNow)
mirrorHealth(victim)
-- physics knockback only for server-owned rigs (NPCs); players get none
if victim.isNPC and victim.root then
victim.root.AssemblyLinearVelocity = toVictim * (atk.knock * 2) + Vector3.new(0, 8, 0)
end
broadcast({
e = "hit", id = attacker.id, tid = victim.id,
dmg = math.floor(dmg + 0.5), pos = pos,
backstab = backstab, heavy = atk.guardBreak or atk.finisher or false,
})
if victim.hp <= 0 then
CombatService.kill(victim, attacker, false)
end
end
local function resolveAttack(attacker, key, atk, mult)
if attacker.dead or attacker.cine then return end
local t = now()
if t < attacker.staggerUntil or t < attacker.gbUntil then return end
local aPos = actorPos(attacker)
local look = actorLook(attacker)
local cosLimit = math.cos(math.rad((atk.angle or 75) * 0.5 + 20))
for _, victim in pairs(CombatService.Actors) do
if victim ~= attacker and not victim.dead and not victim.cine and victim.root then
local offset = actorPos(victim) - aPos
local dist = Vector3.new(offset.X, 0, offset.Z).Magnitude
if dist <= atk.range + 3 and math.abs(offset.Y) < 8 then
local dir = Util.flatDirection(offset)
if atk.angle >= 360 or look:Dot(dir) >= cosLimit then
applyHit(attacker, victim, atk, mult)
end
end
end
end
end
local function beginAttack(actor, key, mult)
local atk = Config.Attacks[key]
if not atk then return end
if actor.stamina < atk.stamina then return end
actor.stamina = actor.stamina - atk.stamina
if actor.blocking then
actor.blocking = false
broadcast({ e = "block", id = actor.id, on = false })
end
setWalkSpeed(actor)
local token = {}
actor.attack = { key = key, token = token, startedAt = now() }
actor.busyUntil = now() + atk.windup + atk.recover
actor.combo.lastKey = key
actor.combo.chainUntil = actor.busyUntil + C.ComboChainWindow
broadcast({ e = "attack", id = actor.id, key = key })
CombatService.AttackStarted:Fire(actor.id, key, atk.windup)
task.delay(atk.windup, function()
if actor.attack and actor.attack.token == token then
resolveAttack(actor, key, atk, mult)
actor.attack = nil
end
end)
end
-- ------------------------------------------------------------------ actions
function CombatService.DoAction(id, action)
local actor = CombatService.Actors[id]
if not actor or actor.dead or actor.cine then return end
local a = action.a
local t = now()
if a == "light" then
-- allow the press slightly early: treat as buffered if recovery is almost done
if not canAct(actor) and actor.attack == nil and not actor.charging
and t >= actor.busyUntil - 0.1 and t >= actor.staggerUntil
and t >= actor.gbUntil and t >= actor.hurtUntil then
task.delay(math.max(0, actor.busyUntil - t), function()
CombatService.DoAction(actor.id, { a = "light" })
end)
return
end
if canAct(actor) then
local chainCfg = nil
if actor.combo.lastKey and t <= actor.combo.chainUntil then
chainCfg = Config.Attacks[actor.combo.lastKey]
end
if chainCfg and chainCfg.nextKey then
beginAttack(actor, chainCfg.nextKey, 1)
else
beginAttack(actor, "L1", 1)
end
end
elseif a == "heavy_start" then
if canAct(actor) and actor.stamina >= Config.Attacks.Heavy.stamina then
actor.charging = t
broadcast({ e = "charge", id = actor.id })
end
elseif a == "heavy_release" then
if actor.charging then
local held = Util.clamp(t - actor.charging, 0, C.HeavyChargeMax)
actor.charging = nil
local mult = 1 + C.HeavyChargeBonus * (held / C.HeavyChargeMax)
beginAttack(actor, "Heavy", mult)
end
elseif a == "dash_attack" then
if canAct(actor) then
beginAttack(actor, "Dash", 1)
end
elseif a == "block" then
if action.on then
if canAct(actor) then
actor.blocking = true
actor.blockStart = t
setWalkSpeed(actor)
broadcast({ e = "block", id = actor.id, on = true })
end
else
if actor.blocking then
actor.blocking = false
setWalkSpeed(actor)
broadcast({ e = "block", id = actor.id, on = false })
end
end
elseif a == "dash" then
if t >= actor.cds.dash and actor.stamina >= C.DashCost
and not actor.blocking and t >= actor.gbUntil and t >= actor.staggerUntil then
actor.cds.dash = t + C.DashCooldown
actor.stamina = actor.stamina - C.DashCost
actor.iframesUntil = t + C.DashIFrames
broadcast({ e = "dash", id = actor.id })
-- NPCs get their dash motion from the server
if actor.isNPC and actor.root then
local dir = action.dir or actorLook(actor)
if typeof(dir) == "Vector3" and dir.Magnitude > 0 then
dir = Util.flatDirection(dir)
actor.root.AssemblyLinearVelocity = dir * C.DashSpeed
end
end
end
elseif a == "sprint" then
actor.sprinting = action.on == true and actor.stamina > C.SprintMinStamina
setWalkSpeed(actor)
elseif a == "stance" then
local i = tonumber(action.i)
if i and i >= 1 and i <= #Config.Stances and canAct(actor) then
actor.stance = i
setWalkSpeed(actor)
broadcast({ e = "stance", id = actor.id, i = i })
end
elseif a == "execute" then
CombatService.tryExecute(actor)
elseif a == "ult" then
CombatService.tryUlt(actor)
end
end
-- ------------------------------------------------------------------ execution
function CombatService.tryExecute(attacker)
if not canAct(attacker) then return end
local t = now()
local aPos = actorPos(attacker)
local best, bestDist = nil, C.ExecuteRange
for _, victim in pairs(CombatService.Actors) do
if victim ~= attacker and not victim.dead and not victim.cine then
local vulnerable = t < victim.gbUntil or victim.hp <= C.ExecuteHPThreshold
if vulnerable then
local d = (actorPos(victim) - aPos).Magnitude
if d < bestDist then
best, bestDist = victim, d
end
end
end
end
if not best then return end
attacker.cine = true
best.cine = true
setWalkSpeed(attacker)
setWalkSpeed(best)
-- place the attacker behind the victim, both anchored for the cinematic
local vcf = best.root.CFrame
local behind = vcf.Position + vcf.LookVector * -3
attacker.root.CFrame = CFrame.lookAt(behind, Vector3.new(vcf.Position.X, behind.Y, vcf.Position.Z))
attacker.root.Anchored = true
best.root.Anchored = true
broadcast({ e = "execute", id = attacker.id, tid = best.id, pos = actorPos(best) })
task.delay(C.ExecuteDuration, function()
attacker.root.Anchored = false
if best.root then
best.root.Anchored = false
end
attacker.cine = false
best.cine = false
if not best.dead then
CombatService.kill(best, attacker, true)
end
if attacker.player and CombatService.DataService then
CombatService.DataService.award(attacker.player, { coins = Config.Rewards.ExecuteBonusCoins })
end
end)
end
function CombatService.tryUlt(actor)
if not canAct(actor) or actor.ult < Config.Ult.Cost then return end
actor.ult = 0
actor.busyUntil = now() + Config.Ult.Hits * Config.Ult.Interval + 0.3
broadcast({ e = "ult", id = actor.id, pos = actorPos(actor) })
for i = 1, Config.Ult.Hits do
task.delay(i * Config.Ult.Interval, function()
if actor.dead then return end
resolveAttack(actor, "UltHit", Config.Attacks.UltHit, 1)
end)
end
end
function CombatService.setBloodMoon(on)
bloodMoon = on
end
-- ------------------------------------------------------------------ character lifecycle
function CombatService.setupCharacter(player, character)
local humanoid = character:WaitForChild("Humanoid", 10)
if not humanoid then return end
character:WaitForChild("HumanoidRootPart", 10)
-- kill the default health regen script
local regen = character:FindFirstChild("Health")
if regen then
regen:Destroy()
end
CombatService.registerActor(character, { player = player })
character.AncestryChanged:Connect(function(_, parent)
if parent == nil then
CombatService.unregister(player.UserId)
end
end)
end
-- ------------------------------------------------------------------ heartbeat
local syncAccum = 0
local function heartbeat(dt)
local t = now()
syncAccum = syncAccum + dt
local doSync = syncAccum >= 0.1
if doSync then
syncAccum = 0
end
for _, actor in pairs(CombatService.Actors) do
if not actor.dead then
-- stamina
local regen = actor.blocking and C.StaminaRegenBlocking or C.StaminaRegen
if actor.sprinting then
actor.stamina = actor.stamina - C.SprintDrain * dt
if actor.stamina <= C.SprintMinStamina then
actor.sprinting = false
setWalkSpeed(actor)
end
elseif not actor.charging and actor.attack == nil then
actor.stamina = Util.clamp(actor.stamina + regen * dt, 0, C.MaxStamina)
end
-- posture decay
if t - actor.lastPostureGain > C.PostureDecayDelay and t >= actor.gbUntil then
actor.posture = math.max(0, actor.posture - C.PostureDecayRate * dt)
end
-- auto-release an over-held heavy
if actor.charging and t - actor.charging > C.HeavyChargeMax + 0.1 then
CombatService.DoAction(actor.id, { a = "heavy_release" })
end
-- combo counter reset
if actor.stats.comboNow > 0 and actor.attack == nil and t > actor.combo.chainUntil then
actor.stats.comboNow = 0
end
-- state sync to owning player
if doSync and actor.player then
remotes.State:FireClient(actor.player, {
hp = actor.hp, po = actor.posture,
st = actor.stamina, ult = actor.ult,
stance = actor.stance,
})
end
end
end
end
-- ------------------------------------------------------------------ init
function CombatService.init(remoteTable, dataService)
remotes = remoteTable
CombatService.DataService = dataService
remotes.Action.OnServerEvent:Connect(function(player, action)
if typeof(action) ~= "table" or typeof(action.a) ~= "string" then
return
end
CombatService.DoAction(player.UserId, action)
end)
RunService.Heartbeat:Connect(heartbeat)
Players.PlayerAdded:Connect(function(player)
player.CharacterAdded:Connect(function(character)
CombatService.setupCharacter(player, character)
end)
task.defer(function()
CombatService.syncActorsTo(player)
end)
if player.Character then
CombatService.setupCharacter(player, player.Character)
end
end)
Players.PlayerRemoving:Connect(function(player)
CombatService.unregister(player.UserId)
end)
end
return CombatService
]]>
- DataService data
local store
local DEFAULT = { coins = 0, xp = 0, level = 1, kills = 0, wins = 0, parries = 0 }
local function deepCopy(t)
local out = {}
for k, v in pairs(t) do
out[k] = v
end
return out
end
local function makeLeaderstats(player, data)
local ls = Instance.new("Folder")
ls.Name = "leaderstats"
for _, def in ipairs({ { "Kills", data.kills }, { "Coins", data.coins }, { "Level", data.level } }) do
local v = Instance.new("IntValue")
v.Name = def[1]
v.Value = def[2]
v.Parent = ls
end
ls.Parent = player
end
local function syncLeaderstats(player, data)
local ls = player:FindFirstChild("leaderstats")
if not ls then return end
ls.Kills.Value = data.kills
ls.Coins.Value = data.coins
ls.Level.Value = data.level
end
local function load(player)
local data = deepCopy(DEFAULT)
if store then
local ok, saved = Util.retry(3, 1, function()
return store:GetAsync("u_" .. player.UserId)
end)
if ok and type(saved) == "table" then
for k, v in pairs(saved) do
data[k] = v
end
end
end
sessions[player.UserId] = data
makeLeaderstats(player, data)
end
local function save(player)
local data = sessions[player.UserId]
if not data or not store then return end
Util.retry(3, 2, function()
store:UpdateAsync("u_" .. player.UserId, function()
return data
end)
return true
end)
end
function DataService.get(player)
return sessions[player.UserId]
end
function DataService.award(player, gains)
local data = sessions[player.UserId]
if not data then return end
data.coins = data.coins + (gains.coins or 0)
data.xp = data.xp + (gains.xp or 0)
data.kills = data.kills + (gains.kills or 0)
data.wins = data.wins + (gains.wins or 0)
data.parries = data.parries + (gains.parries or 0)
-- level-up check
local needed = data.level * Config.Rewards.XPPerLevel
while data.xp >= needed do
data.xp = data.xp - needed
data.level = data.level + 1
needed = data.level * Config.Rewards.XPPerLevel
if DataService.onLevelUp then
DataService.onLevelUp(player, data.level)
end
end
syncLeaderstats(player, data)
end
function DataService.init()
local ok, s = pcall(function()
return DataStoreService:GetDataStore("TLS_v1")
end)
if ok then
store = s
else
warn("[TLS] DataStore unavailable (Studio without API access?) — progress will not persist")
end
Players.PlayerAdded:Connect(load)
for _, p in ipairs(Players:GetPlayers()) do
task.spawn(load, p)
end
Players.PlayerRemoving:Connect(function(player)
save(player)
sessions[player.UserId] = nil
end)
-- autosave
task.spawn(function()
while true do
task.wait(120)
for _, p in ipairs(Players:GetPlayers()) do
task.spawn(save, p)
end
end
end)
if not RunService:IsStudio() then
game:BindToClose(function()
for _, p in ipairs(Players:GetPlayers()) do
save(p)
end
task.wait(2)
end)
end
end
return DataService
]]>
- MapService
- WeatherService
- StarterPlayer
- StarterPlayerScripts
- Client
- AnimationController rig
local JOINTS = { "Root", "Neck", "RS", "LS", "RH", "LH" }
local JOINT_NAMES = {
Root = { "RootJoint", "Waist" },
Neck = { "Neck" },
RS = { "Right Shoulder", "RightShoulder" },
LS = { "Left Shoulder", "LeftShoulder" },
RH = { "Right Hip", "RightHip" },
LH = { "Left Hip", "LeftHip" },
}
local FIELDS = { "x", "y", "z", "py" }
-- ------------------------------------------------------------- rig setup
local function findJoints(model)
local found = {}
for _, desc in ipairs(model:GetDescendants()) do
if desc:IsA("Motor6D") then
for abstract, names in pairs(JOINT_NAMES) do
for _, n in ipairs(names) do
if desc.Name == n and not found[abstract] then
found[abstract] = { motor = desc, baseC0 = desc.C0 }
end
end
end
end
end
return found
end
local function newPoseState()
local state = {}
for _, j in ipairs(JOINTS) do
state[j] = { x = 0, y = 0, z = 0, py = 0 }
end
return state
end
function AnimationController.addActor(id, model, isNPC)
if rigs[id] then
AnimationController.removeActor(id)
end
local rig = {
id = id, model = model, isNPC = isNPC,
joints = findJoints(model),
current = newPoseState(),
clip = nil, clipT = 0, clipName = nil, clipExpire = nil,
blocking = false,
legPhase = 0,
root = model:FindFirstChild("HumanoidRootPart"),
breath = math.random() * 6,
}
rig.katana = model:FindFirstChild("Katana")
if not rig.katana then
task.delay(1, function()
if rig.model then
rig.katana = rig.model:FindFirstChild("Katana")
end
end)
end
rigs[id] = rig
return rig
end
function AnimationController.removeActor(id)
rigs[id] = nil
end
-- ------------------------------------------------------------- clip control
function AnimationController.play(id, clipName, expireAfter)
local rig = rigs[id]
local clip = AnimPoses[clipName]
if not rig or not clip then return end
rig.clip = clip
rig.clipName = clipName
rig.clipT = 0
rig.clipExpire = expireAfter and (os.clock() + expireAfter) or nil
end
function AnimationController.stop(id, onlyIfClip)
local rig = rigs[id]
if not rig then return end
if onlyIfClip and rig.clipName ~= onlyIfClip then return end
rig.clip = nil
rig.clipName = nil
end
function AnimationController.setBlocking(id, on)
local rig = rigs[id]
if rig then
rig.blocking = on
end
end
-- ------------------------------------------------------------- sampling
local function sampleClip(clip, u, target)
local keys = clip.keys
local a, b = keys[1], keys[#keys]
for i = 1, #keys - 1 do
if u >= keys[i].t and u <= keys[i + 1].t then
a, b = keys[i], keys[i + 1]
break
end
end
local span = b.t - a.t
local f = span > 0 and Util.ease(Util.clamp((u - a.t) / span, 0, 1)) or 1
for _, j in ipairs(JOINTS) do
local pa = a.pose[j]
local pb = b.pose[j]
local tj = target[j]
for _, field in ipairs(FIELDS) do
local va = pa and pa[field] or 0
local vb = pb and pb[field] or 0
tj[field] = va + (vb - va) * f
end
end
end
local function sampleGuard(rig, target, dt)
rig.breath = rig.breath + dt
sampleClip(AnimPoses.Guard, (rig.breath % AnimPoses.Guard.dur) / AnimPoses.Guard.dur, target)
-- velocity lean
if rig.root then
local vel = rig.root.AssemblyLinearVelocity
local speed = Vector3.new(vel.X, 0, vel.Z).Magnitude
if speed > 2 then
local look = rig.root.CFrame.LookVector
local forwardness = Util.flatDirection(vel):Dot(Util.flatDirection(look))
target.Root.x = target.Root.x + Util.clamp(speed * 0.5 * forwardness, -8, 10)
if speed > Config.Combat.SprintSpeed - 2 then
-- sprint: katana carried low and back
local sp = AnimPoses.Sprint.keys[1].pose
target.Root.x = target.Root.x + (sp.Root and sp.Root.x or 0)
target.RS.x = sp.RS.x
target.RS.y = sp.RS.y
target.LS.x = sp.LS.x
target.LS.y = sp.LS.y
end
end
end
end
local scratch = newPoseState()
local function updateRig(rig, dt, frozen)
if not rig.model or not rig.model.Parent then
rigs[rig.id] = nil
return
end
local target = scratch
-- advance clip
if rig.clip and not frozen then
rig.clipT = rig.clipT + dt
local dur = rig.clip.dur
if rig.clipT >= dur then
if rig.clip.loop then
rig.clipT = rig.clipT % dur
elseif rig.clip.hold then
rig.clipT = dur
else
rig.clip = nil
rig.clipName = nil
end
end
if rig.clipExpire and os.clock() > rig.clipExpire then
rig.clip = nil
rig.clipName = nil
rig.clipExpire = nil
end
end
if rig.clip then
sampleClip(rig.clip, Util.clamp(rig.clipT / rig.clip.dur, 0, 1), target)
elseif rig.blocking then
sampleClip(AnimPoses.Block, 1, target)
else
sampleGuard(rig, target, dt)
end
-- NPC procedural leg walk (players get real locomotion from Animate)
if rig.isNPC and rig.root then
local vel = rig.root.AssemblyLinearVelocity
local speed = Vector3.new(vel.X, 0, vel.Z).Magnitude
if speed > 1 then
rig.legPhase = rig.legPhase + dt * (speed * 0.9)
local swing = math.sin(rig.legPhase) * Util.clamp(speed * 3.2, 0, 38)
-- only override legs the clip left neutral
if math.abs(target.RH.x) < 1 then target.RH.x = swing end
if math.abs(target.LH.x) < 1 then target.LH.x = -swing end
end
end
-- smooth toward target (weight = the "feel")
local alpha = frozen and 0 or Util.clamp(dt * 14, 0, 1)
for _, j in ipairs(JOINTS) do
local cur, tgt = rig.current[j], target[j]
for _, field in ipairs(FIELDS) do
cur[field] = cur[field] + (tgt[field] - cur[field]) * alpha
end
end
-- apply to motors: C0' = T(pos + py) * R(character space) * Rot(base)
for _, j in ipairs(JOINTS) do
local joint = rig.joints[j]
if joint and joint.motor.Parent then
local p = rig.current[j]
local base = joint.baseC0
local rot = CFrame.Angles(math.rad(-p.x), math.rad(-p.y), math.rad(p.z))
joint.motor.C0 = CFrame.new(base.Position + Vector3.new(0, p.py, 0)) * rot * base.Rotation
end
end
-- katana trail window
if rig.katana then
local blade = rig.katana:FindFirstChild("Blade")
local trail = blade and blade:FindFirstChild("SwingTrail")
if trail then
local wantOn = false
if rig.clip and rig.clip.trail then
local u = rig.clipT / rig.clip.dur
wantOn = u >= rig.clip.trail[1] and u <= rig.clip.trail[2]
end
if trail.Enabled ~= wantOn then
trail.Enabled = wantOn
end
end
end
end
-- ------------------------------------------------------------- events
local CLIP_FOR_EVENT = {
guardbreak = { clip = "GuardBroken", expire = Config.Combat.GuardBreakStun },
dash = { clip = "Dash", expire = 0.3 },
charge = { clip = "HeavyCharge" },
ult = { clip = "HeavyRelease" },
}
function AnimationController.init(remotes)
remotes.Actors.OnClientEvent:Connect(function(msg)
if msg.gone then
AnimationController.removeActor(msg.id)
elseif msg.model then
task.defer(function()
if msg.model.Parent then
AnimationController.addActor(msg.id, msg.model, msg.npc)
end
end)
end
end)
remotes.Combat.OnClientEvent:Connect(function(ev)
local e = ev.e
if e == "attack" then
local clipName = AnimPoses.AttackClips[ev.key]
if clipName then
AnimationController.setBlocking(ev.id, false)
AnimationController.play(ev.id, clipName)
end
elseif e == "block" then
AnimationController.setBlocking(ev.id, ev.on)
if ev.on then
AnimationController.stop(ev.id)
end
elseif e == "parry" then
AnimationController.play(ev.id, "ParryFlash")
if ev.aid then
AnimationController.play(ev.aid, "Stagger")
end
Bus.hitstop(0.07)
elseif e == "hit" then
if not ev.blocked and ev.tid then
AnimationController.play(ev.tid, "Hurt")
end
Bus.hitstop(ev.heavy and 0.06 or 0.035)
elseif e == "guardbreak" or e == "dash" or e == "charge" then
local def = CLIP_FOR_EVENT[e]
AnimationController.setBlocking(ev.id, false)
AnimationController.play(ev.id, def.clip, def.expire)
elseif e == "ult" then
for i = 0, Config.Ult.Hits - 1 do
task.delay(i * Config.Ult.Interval, function()
AnimationController.play(ev.id, i % 2 == 0 and "HeavyRelease" or "Slash1")
end)
end
elseif e == "execute" then
AnimationController.play(ev.id, "ExecuteAttacker")
AnimationController.play(ev.tid, "ExecuteVictim")
elseif e == "death" then
if not (rigs[ev.id] and rigs[ev.id].clipName == "ExecuteVictim") then
AnimationController.play(ev.id, "Death")
end
elseif e == "stance" then
-- brief acknowledgment flourish
AnimationController.play(ev.id, "ParryFlash")
end
end)
RunService.RenderStepped:Connect(function(dt)
local frozen = os.clock() < Bus.hitstopUntil
for _, rig in pairs(rigs) do
updateRig(rig, dt, frozen)
end
end)
end
function AnimationController.getRig(id)
return rigs[id]
end
return AnimationController
]]>
- CameraController cine.untilT
or not cine.victim or not cine.victim.Parent then
cine = nil
camera.CameraType = Enum.CameraType.Custom
else
local vRoot = cine.victim:FindFirstChild("HumanoidRootPart")
local aRoot = cine.attacker and cine.attacker:FindFirstChild("HumanoidRootPart")
if vRoot then
camera.CameraType = Enum.CameraType.Scriptable
local mid = aRoot and (vRoot.Position + aRoot.Position) / 2 or vRoot.Position
local angle = (os.clock() * 0.35) % (math.pi * 2)
local eye = mid + Vector3.new(math.cos(angle) * 11, 3.4, math.sin(angle) * 11)
camera.CFrame = camera.CFrame:Lerp(CFrame.lookAt(eye, mid + Vector3.new(0, 1.4, 0)), Util.clamp(dt * 5, 0, 1))
end
end
elseif lockTarget and lockTarget.Parent and root then
-- lock-on: shoulder frame holding both fighters
local tRoot = lockTarget:FindFirstChild("HumanoidRootPart")
if tRoot then
camera.CameraType = Enum.CameraType.Scriptable
local toTarget = Util.flatDirection(tRoot.Position - root.Position)
local eye = root.Position - toTarget * 11 + Vector3.new(0, 4.4, 0)
+ camera.CFrame.RightVector * 1.6
local look = (root.Position + tRoot.Position) / 2 + Vector3.new(0, 1.2, 0)
camera.CFrame = camera.CFrame:Lerp(CFrame.lookAt(eye, look), Util.clamp(dt * 9, 0, 1))
else
lockTarget = nil
camera.CameraType = Enum.CameraType.Custom
end
else
if camera.CameraType == Enum.CameraType.Scriptable then
camera.CameraType = Enum.CameraType.Custom
end
end
-- FOV: sprint stretch + punches
local targetFOV = BASE_FOV
if humanoid and humanoid.WalkSpeed > 18 and humanoid.MoveDirection.Magnitude > 0.1 then
targetFOV = SPRINT_FOV
end
fovPunch = fovPunch * math.max(0, 1 - dt * fovPunchDecay)
camera.FieldOfView = Util.lerp(camera.FieldOfView, targetFOV + fovPunch, Util.clamp(dt * 6, 0, 1))
-- trauma shake (smooth pseudo-noise, decays quadratically)
if trauma > 0.003 then
noiseT = noiseT + dt * 30
local amp = trauma * trauma
local rx = (math.noise(noiseT, 0) or 0) * amp * 0.06
local ry = (math.noise(0, noiseT) or 0) * amp * 0.06
local rz = (math.noise(noiseT, noiseT) or 0) * amp * 0.02
camera.CFrame = camera.CFrame * CFrame.Angles(rx, ry, rz)
trauma = math.max(0, trauma - dt * 2.2)
end
end)
-- big deaths near us rumble
remotes.Combat.OnClientEvent:Connect(function(ev)
if ev.e == "death" and ev.pos then
local char = player.Character
local root = char and char:FindFirstChild("HumanoidRootPart")
if root and (root.Position - ev.pos).Magnitude < 40 then
shake(0.5)
end
end
end)
end
function CameraController.setLockTarget(model)
lockTarget = model
end
return CameraController
]]>
- ClientBus Bus.hitstopUntil then
Bus.hitstopUntil = untilT
end
end
return Bus
]]>
- CombatController model (from registry)
local vulnerableUntil = {} -- id -> os.clock() deadline
local lastDash = 0
local charging = false
local sprinting = false
local lockId = nil
local function send(action)
remotes.Action:FireServer(action)
end
local function character()
return player.Character
end
local function root()
local char = character()
return char and char:FindFirstChild("HumanoidRootPart")
end
-- ------------------------------------------------------------- actions
local function doLight()
if charging then return end
if os.clock() - lastDash < 0.25 then
send({ a = "dash_attack" })
else
send({ a = "light" })
end
end
local function heavyStart()
charging = true
send({ a = "heavy_start" })
end
local function heavyRelease()
if charging then
charging = false
send({ a = "heavy_release" })
end
end
local function setBlock(on)
send({ a = "block", on = on })
AnimationController.setBlocking(myId, on) -- instant pose; server confirms
end
local function doDash()
local r = root()
local char = character()
local humanoid = char and char:FindFirstChildOfClass("Humanoid")
if not r or not humanoid then return end
lastDash = os.clock()
send({ a = "dash" })
-- immediate motion: server has validated cost by the time others see it
local dir = humanoid.MoveDirection.Magnitude > 0.1 and humanoid.MoveDirection
or Util.flatDirection(r.CFrame.LookVector)
r.AssemblyLinearVelocity = dir * Config.Combat.DashSpeed + Vector3.new(0, 2, 0)
Bus.FOVPunch:Fire(6, 0.3)
end
local function setSprint(on)
if sprinting ~= on then
sprinting = on
send({ a = "sprint", on = on })
end
end
local function doExecute()
send({ a = "execute" })
end
local function doUlt()
send({ a = "ult" })
end
local function setStance(i)
send({ a = "stance", i = i })
end
-- ------------------------------------------------------------- lock-on
local function nearestActor()
local r = root()
if not r then return nil, nil end
local best, bestId, bestDist = nil, nil, 70
for id, model in pairs(actorModels) do
if id ~= myId and model.Parent then
local mRoot = model:FindFirstChild("HumanoidRootPart")
local humanoid = model:FindFirstChildOfClass("Humanoid")
if mRoot and humanoid and humanoid.Health > 0 then
local d = (mRoot.Position - r.Position).Magnitude
if d < bestDist then
best, bestId, bestDist = model, id, d
end
end
end
end
return best, bestId
end
local function toggleLock()
if lockId then
lockId = nil
Bus.LockOn:Fire(nil, nil)
local char = character()
local humanoid = char and char:FindFirstChildOfClass("Humanoid")
if humanoid then
humanoid.AutoRotate = true
end
else
local model, id = nearestActor()
if model then
lockId = id
Bus.LockOn:Fire(id, model)
local char = character()
local humanoid = char and char:FindFirstChildOfClass("Humanoid")
if humanoid then
humanoid.AutoRotate = false
end
end
end
end
-- ------------------------------------------------------------- input wiring
local function bindInputs()
UserInputService.InputBegan:Connect(function(input, processed)
if processed then return end
local t = input.UserInputType
local k = input.KeyCode
if t == Enum.UserInputType.MouseButton1 then
doLight()
elseif k == Enum.KeyCode.R then
heavyStart()
elseif k == Enum.KeyCode.F then
setBlock(true)
elseif k == Enum.KeyCode.Q then
doDash()
elseif k == Enum.KeyCode.LeftShift then
setSprint(true)
elseif k == Enum.KeyCode.E then
doExecute()
elseif k == Enum.KeyCode.V then
doUlt()
elseif k == Enum.KeyCode.Tab then
toggleLock()
elseif k == Enum.KeyCode.One then
setStance(1)
elseif k == Enum.KeyCode.Two then
setStance(2)
elseif k == Enum.KeyCode.Three then
setStance(3)
elseif k == Enum.KeyCode.Four then
setStance(4)
elseif k == Enum.KeyCode.ButtonR2 then
doLight()
elseif k == Enum.KeyCode.ButtonL2 then
setBlock(true)
elseif k == Enum.KeyCode.ButtonX then
doDash()
elseif k == Enum.KeyCode.ButtonY then
heavyStart()
elseif k == Enum.KeyCode.ButtonB then
doExecute()
elseif k == Enum.KeyCode.ButtonR3 then
toggleLock()
elseif k == Enum.KeyCode.DPadUp then
doUlt()
end
end)
UserInputService.InputEnded:Connect(function(input)
local k = input.KeyCode
if k == Enum.KeyCode.R or k == Enum.KeyCode.ButtonY then
heavyRelease()
elseif k == Enum.KeyCode.F or k == Enum.KeyCode.ButtonL2 then
setBlock(false)
elseif k == Enum.KeyCode.LeftShift then
setSprint(false)
end
end)
-- touch buttons
if UserInputService.TouchEnabled and not UserInputService.KeyboardEnabled then
local function bindBtn(name, title, pos, began, ended)
ContextActionService:BindAction(name, function(_, state)
if state == Enum.UserInputState.Begin then
began()
elseif state == Enum.UserInputState.End and ended then
ended()
end
return Enum.ContextActionResult.Sink
end, true)
ContextActionService:SetTitle(name, title)
ContextActionService:SetPosition(name, pos)
end
bindBtn("TLS_ATK", "斬", UDim2.new(1, -95, 1, -140), doLight)
bindBtn("TLS_HVY", "重", UDim2.new(1, -165, 1, -95), heavyStart, heavyRelease)
bindBtn("TLS_BLK", "防", UDim2.new(1, -95, 1, -215), function() setBlock(true) end, function() setBlock(false) end)
bindBtn("TLS_DSH", "駆", UDim2.new(1, -165, 1, -180), doDash)
bindBtn("TLS_ULT", "龍", UDim2.new(1, -40, 1, -215), doUlt)
bindBtn("TLS_EXE", "閃", UDim2.new(1, -230, 1, -140), doExecute)
bindBtn("TLS_LCK", "鎖", UDim2.new(1, -40, 1, -285), toggleLock)
end
end
-- ------------------------------------------------------------- loops
local function watchVulnerability()
RunService.Heartbeat:Connect(function()
local r = root()
if not r then
Bus.ExecutePrompt:Fire(false)
return
end
local t = os.clock()
local showPrompt = false
for id, deadline in pairs(vulnerableUntil) do
if t > deadline then
vulnerableUntil[id] = nil
else
local model = actorModels[id]
local mRoot = model and model:FindFirstChild("HumanoidRootPart")
if mRoot and (mRoot.Position - r.Position).Magnitude < Config.Combat.ExecuteRange then
showPrompt = true
end
end
end
-- also low-HP actors nearby
if not showPrompt then
for id, model in pairs(actorModels) do
if id ~= myId and model.Parent then
local humanoid = model:FindFirstChildOfClass("Humanoid")
local mRoot = model:FindFirstChild("HumanoidRootPart")
if humanoid and mRoot and humanoid.Health > 0
and humanoid.Health <= Config.Combat.ExecuteHPThreshold
and (mRoot.Position - r.Position).Magnitude < Config.Combat.ExecuteRange then
showPrompt = true
end
end
end
end
Bus.ExecutePrompt:Fire(showPrompt)
-- lock-on facing
if lockId then
local model = actorModels[lockId]
local mRoot = model and model.Parent and model:FindFirstChild("HumanoidRootPart")
local humanoid = model and model:FindFirstChildOfClass("Humanoid")
if mRoot and humanoid and humanoid.Health > 0
and (mRoot.Position - r.Position).Magnitude < 90 then
r.CFrame = Util.yawCFrame(r.Position, mRoot.Position)
else
toggleLock()
end
end
end)
end
function CombatController.init(remoteTable)
remotes = remoteTable
remotes.Actors.OnClientEvent:Connect(function(msg)
if msg.gone then
actorModels[msg.id] = nil
if lockId == msg.id then
toggleLock()
end
elseif msg.model then
actorModels[msg.id] = msg.model
end
end)
remotes.Combat.OnClientEvent:Connect(function(ev)
if ev.e == "guardbreak" then
vulnerableUntil[ev.id] = os.clock() + Config.Combat.GuardBreakStun
elseif ev.e == "death" then
vulnerableUntil[ev.id] = nil
if ev.id == myId then
charging = false
sprinting = false
if lockId then
toggleLock()
end
end
elseif ev.e == "execute" then
local attacker = actorModels[ev.id]
local victim = actorModels[ev.tid]
local r = root()
if r and ev.pos and (r.Position - ev.pos).Magnitude < 60 then
Bus.ExecuteCam:Fire(attacker, victim, Config.Combat.ExecuteDuration + 0.3)
end
end
end)
bindInputs()
watchVulnerability()
end
return CombatController
]]>
- SoundController
- UIController 6 then
for _, child in ipairs(feedFrame:GetChildren()) do
if child:IsA("TextLabel") then
child:Destroy()
break
end
end
end
task.delay(5, function()
TweenService:Create(entry, TweenInfo.new(1), { TextTransparency = 1 }):Play()
task.delay(1.1, function()
entry:Destroy()
end)
end)
end
local function damageNumber(position, text, color, big)
local part = make("Part", {
Transparency = 1, Anchored = true, CanCollide = false, CanQuery = false, CanTouch = false,
Size = Vector3.new(0.2, 0.2, 0.2), Position = position, Parent = Workspace,
})
local bb = make("BillboardGui", {
Size = UDim2.new(0, 200, 0, 50), AlwaysOnTop = true,
StudsOffset = Vector3.new(math.random(-10, 10) / 10, 1.2, 0), Parent = part,
})
local lbl = make("TextLabel", {
BackgroundTransparency = 1, Size = UDim2.new(1, 0, 1, 0),
Font = Enum.Font.Garamond, Text = text, TextSize = big and 30 or 21,
TextColor3 = color, TextStrokeTransparency = 0.4,
TextStrokeColor3 = Color3.new(0, 0, 0), Parent = bb,
})
TweenService:Create(bb, TweenInfo.new(0.9, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), {
StudsOffset = bb.StudsOffset + Vector3.new(0, 2.2, 0),
}):Play()
TweenService:Create(lbl, TweenInfo.new(0.9), { TextTransparency = 1, TextStrokeTransparency = 1 }):Play()
task.delay(1, function()
part:Destroy()
end)
end
local function nameplate(model, displayName)
local head = model:FindFirstChild("Head")
if not head then return end
local bb = make("BillboardGui", {
Name = "TLSPlate", Size = UDim2.new(0, 150, 0, 40), MaxDistance = 110,
StudsOffset = Vector3.new(0, 2.6, 0), Parent = head,
})
make("TextLabel", {
BackgroundTransparency = 1, Size = UDim2.new(1, 0, 0, 18),
Font = Enum.Font.Garamond, Text = displayName, TextSize = 14,
TextColor3 = PAL.Washi, TextStrokeTransparency = 0.5, Parent = bb,
})
local hpHolder = make("Frame", {
BackgroundColor3 = Color3.fromRGB(20, 18, 22), BorderSizePixel = 0,
Position = UDim2.new(0.15, 0, 0, 22), Size = UDim2.new(0.7, 0, 0, 5), Parent = bb,
})
local hpBar = make("Frame", {
BackgroundColor3 = PAL.Crimson, BorderSizePixel = 0,
Size = UDim2.new(1, 0, 1, 0), Parent = hpHolder,
})
local humanoid = model:FindFirstChildOfClass("Humanoid")
if humanoid then
humanoid.HealthChanged:Connect(function(h)
hpBar.Size = UDim2.new(Util.clamp(h / humanoid.MaxHealth, 0, 1), 0, 1, 0)
end)
end
end
-- ------------------------------------------------------------- init
local combo, comboTimer = 0, 0
function UIController.init(remotes)
buildHUD()
Bus.Announce:Connect(announce)
Bus.Letterbox:Connect(function(on)
local h = on and 0.09 or 0
local info = TweenInfo.new(0.5, Enum.EasingStyle.Quart, Enum.EasingDirection.InOut)
TweenService:Create(lbTop, info, { Size = UDim2.new(1, 0, h, 0) }):Play()
TweenService:Create(lbBottom, info, { Size = UDim2.new(1, 0, h, 0) }):Play()
end)
Bus.ExecutePrompt:Connect(function(visible)
execPrompt.Visible = visible
end)
remotes.State.OnClientEvent:Connect(function(s)
hpFill.Size = UDim2.new(Util.clamp(s.hp / Config.Combat.MaxHP, 0, 1), 0, 1, 0)
poFill.Size = UDim2.new(Util.clamp(s.po / Config.Combat.MaxPosture, 0, 1), 0, 1, 0)
stFill.Size = UDim2.new(Util.clamp(s.st / Config.Combat.MaxStamina, 0, 1), 0, 1, 0)
ultFill.Size = UDim2.new(Util.clamp(s.ult / Config.Combat.MaxUlt, 0, 1), 0, 1, 0)
local ready = s.ult >= Config.Combat.MaxUlt
ultKanji.TextColor3 = ready and PAL.Kin or PAL.Washi
ultKanji.TextTransparency = ready and 0 or 0.45
local stance = Config.Stances[s.stance]
if stance then
stanceKanji.Text = stance.kanji
stanceName.Text = stance.id:upper() .. " STANCE — " .. stance.desc
end
end)
remotes.Announce.OnClientEvent:Connect(function(a)
announce(a.kanji, a.text, a.dur)
end)
remotes.KillFeed.OnClientEvent:Connect(function(k)
if k.killer then
feed(("⚔ %s %s %s"):format(k.killer, k.executed and "executed" or "cut down", k.victim), k.executed)
else
feed(("%s has fallen"):format(k.victim))
end
end)
remotes.Actors.OnClientEvent:Connect(function(msg)
if msg.npc and msg.model and not msg.gone then
task.defer(function()
if msg.model.Parent then
nameplate(msg.model, msg.npcName or "浪人")
end
end)
end
end)
local myId = player.UserId
remotes.Combat.OnClientEvent:Connect(function(ev)
if ev.e == "hit" and ev.pos then
if ev.blocked then
if ev.tid == myId and ev.guardBreak then
damageNumber(ev.pos, "GUARD SHATTERED", Color3.fromRGB(255, 120, 90), true)
end
else
damageNumber(ev.pos, tostring(ev.dmg), ev.backstab and Color3.fromRGB(224, 138, 90) or PAL.Washi, ev.heavy)
if ev.backstab then
damageNumber(ev.pos + Vector3.new(0, 1, 0), "BACKSTAB", Color3.fromRGB(224, 138, 90), false)
end
if ev.id == myId then
combo = combo + 1
comboTimer = os.clock() + 1.8
comboCount.Text = tostring(combo)
comboFrame.Visible = combo >= 2
end
end
elseif ev.e == "parry" and ev.pos then
damageNumber(ev.pos + Vector3.new(0, 1, 0), "弾き PERFECT PARRY", PAL.Kin, true)
if ev.id == myId then
announce("弾き", "PERFECT PARRY", 0.9)
end
elseif ev.e == "guardbreak" and ev.pos then
damageNumber(ev.pos + Vector3.new(0, 1.5, 0), "崩し GUARD BROKEN", Color3.fromRGB(255, 106, 94), true)
elseif ev.e == "execute" then
announce("一閃", "EXECUTION", 1.6)
elseif ev.e == "ult" then
announce("龍斬", "DRAGON SLASH", 1.4)
elseif ev.e == "death" and ev.id == myId then
announce("敗北", "SLAIN — THE WIND CARRIES YOU HOME", 3)
combo = 0
comboFrame.Visible = false
elseif ev.e == "evade" and ev.pos then
damageNumber(ev.pos, "EVADED", Color3.fromRGB(159, 214, 200), false)
end
end)
RunService.Heartbeat:Connect(function()
if comboFrame.Visible and os.clock() > comboTimer then
combo = 0
comboFrame.Visible = false
end
end)
announce("最後ノ侍", "THE LAST SAMURAI", 3.4)
feed("the wind rises — draw your blade", true)
end
return UIController
]]>
- VFXController
- Lighting4true
- Workspace
- SoundService
- StarterGui
- StarterPack