教程 · 游戏系统

如何在 Roblox Studio 中做一把剑

Roblox 里的剑是一个 Tool,它有三项任务,分给两个脚本完成:玩家的设备察觉点击并播放挥砍动作,服务器则决定谁被击中、掉了多少生命值。在这篇教程里,我们会写好这两个脚本,包括玩家无法伪造的冷却时间和攻击判定框,并说明动画放在哪里。

更新于 2026年11月20日阅读约 5 分钟作者

要点

在 StarterPack 中放一个名为 Sword 的 Tool,里面有一个名为 Handle 的零件。Tool 中的 LocalScript 监听 Tool.Activated,播放挥砍动画,并不带参数地触发一个 RemoteEvent。ServerScriptService 中的 Script 检查冷却时间、玩家是否活着并手持这把剑,通过 workspace:GetPartBoundsInBox 找出玩家前方盒子里的 Humanoid,并对每个目标调用一次 Humanoid:TakeDamage。

  • 不要用剑刃的 Touched 事件造成伤害:玩家的设备控制着自己的角色,可以在任何地方触发 Touched,Roblox 关于 network ownership 的页面举的例子正是剑。
  • 客户端既不发送目标,也不发送伤害。冷却时间、攻击判定框和伤害数值都由服务器掌握。
  • 只要目标身上有 ForceField,TakeDamage 就不起作用,例如在 SpawnLocation 上重生后的前 10 秒。
  • 攻击穿墙,或者在挥砍动作视觉上碰到目标之前就命中了?请使用带前摇和穿墙检查的服务端脚本版本。
本页内容
  1. 构成方式
  2. 1. 搭建 Tool
  3. 2. 服务端脚本
  4. 3. LocalScript
  5. 攻击判定框
  6. 攻击判定方式
  7. 前摇与穿墙检查
  8. 挥砍动画
  9. 旧教程
  10. 防护的边界
  11. 4. 测试
  12. 扩展
  13. Common errors
  14. 用 RoCode
  15. 常见问题
  16. 参考资料

一把能用的剑是怎么构成的

示意间隔至少 0.6 秒的挥砍每次扣除 20 点生命值,冷却时间内的点击没有效果,第五次命中击倒骨架。

能在真正的游戏里使用的剑,分布在玩家的设备和服务器之间。Roblox 关于工具的页面说,工具的输入应放在 LocalScript 中,因为只有玩家的设备知道输入何时发生,而且大多数工具都需要 LocalScript、服务端 Script 以及两者之间的 RemoteEvent。本教程用的正是这种分工。一次挥砍的过程如下:

  1. 玩家装备 Sword 后点击、轻触或按下手柄扳机。LocalScript 中的 Tool.Activated 被触发。
  2. LocalScript 播放挥砍动画(如果有的话),并触发 RemoteEvent SwordSwing。除此之外它什么都不发送。
  3. 服务端 Script 检查冷却时间、玩家是否活着,以及 Sword 是否在他手里。
  4. 服务器在玩家角色前方建立自己的攻击判定框,找出其中的每个 Humanoid。
  5. 这些 Humanoid 各通过 TakeDamage 失去一次生命值。
剑由哪些部分组成
组成部分位置作用
Tool SwordStarterPack玩家手里拿的东西。每当玩家角色重生时,Roblox 都会把 StarterPack 中的所有内容复制到玩家的 Backpack。
Part HandleTool 内部角色握住的零件。剑刃焊接在它上面。
LocalScript SwordClientTool 内部感知点击,播放挥砍动画,并触发 remote。
RemoteEvent SwordSwingReplicatedStorage(由 SwordService 创建)把“我挥砍了”从玩家设备传给服务器,不带参数。
Script SwordServiceServerScriptService检查每次挥砍,找出谁站在玩家前方,并造成伤害。这是唯一可能发生命中的地方。
剑做好后的 Explorer。游戏运行时,SwordService 会在 ReplicatedStorage 中添加一个名为 SwordSwing 的 RemoteEvent。
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

第 1 步:搭建剑的 Tool

  1. 在 Explorer 中把鼠标移到 Workspace 上,点击 + 按钮,插入一个 Tool。把它重命名为 Sword。服务端脚本查找的正是这个名字。按照 Roblox 关于工具页面的建议,你在 Workspace 中搭建这把剑,因为在那里能看到它的零件,可以移动和调整大小。最后一步会把它移到 StarterPack。
  2. 在 Tool 中插入一个 Part,命名为 Handle。这是角色握住剑的剑柄。它必须是 Tool 的直接子对象,而且是唯一叫这个名字的零件:有两个 Handle 时,Roblox 会随机选一个,角色可能会握住剑刃。
  3. 在 Tool 中插入第二个 Part,命名为 Blade,做出形状,并让它从 Handle 的顶部伸出来。
  4. 在 Blade 中插入一个 WeldConstraint。在 Properties 窗口中把它的 Part0 设为 Handle,Part1 设为 Blade,这样玩家拿着剑时它能保持完整。
  5. 选中两个零件,确认 Anchored 已关闭。工具里被锚固的零件会在角色装备它时把角色钉在原地。把两者的 CanCollide 也关掉,这样挥砍时剑刃不会撞到玩家和墙壁。
  6. 选中 Tool,取消勾选 CanBeDropped。勾选时,按 Backspace 会把剑扔到 Workspace 里。
  7. 把做好的 Sword 从 Workspace 拖到 StarterPack。留在 Workspace 里的 Tool 是一个只有一个玩家能捡走的道具,而不是一开始就在每个人 Backpack 里的剑。

用单个 MeshPart 做的剑也可以:把这个 MeshPart 命名为 Handle,跳过焊接即可。如果测试时角色握剑的角度很奇怪,选中 Tool,在 Properties 窗口中调整它的握持属性(GripPos、GripForward、GripRight 和 GripUp)。

第 2 步:添加服务端脚本

把鼠标移到 ServerScriptService 上,插入一个名为 SwordService 的 Script,并把下面的代码粘贴进去。这是唯一可能发生剑击命中的地方。开头的设置就是你应该修改的那几行。

Script 位置: ServerScriptService 名称: SwordService
-- ServerScriptService 中名为 SwordService 的 Script。
-- 唯一可能发生剑击命中的地方:检查挥砍,用自己的攻击判定框找出
-- 攻击者前方的目标,并造成伤害。

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- 设置
local SWORD_NAME = "Sword" -- StarterPack 中 Tool 的名字
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- 在 SwordClient 中保持相同的值
local HIT_RANGE = 6 -- 攻击者前方的 stud 数
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false:同队玩家不能互相伤害
-- 恰好间隔 COOLDOWN_SECONDS 发出的挥砍,经过网络延迟后可能到达得
-- 稍微更近一些,所以服务器留出这个余量,不会丢掉真实的挥砍
local NETWORK_SLACK = 0.1

-- 剑的 LocalScript 触发的 remote。它不带参数:谁被击中
-- 由服务器决定,所以客户端没有东西可以伪造。
local swingEvent = Instance.new("RemoteEvent")
swingEvent.Name = "SwordSwing"
swingEvent.Parent = ReplicatedStorage

local lastSwing: { [Player]: number } = {}

local function isTeammate(attacker: Player, target: Player?): boolean
	if FRIENDLY_FIRE or not target then
		return false
	end
	-- 中立玩家(没有队伍)总是可以互相攻击
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. 每个冷却时间只算一次挥砍,无论 remote 被触发得多频繁
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. 攻击者必须活着并且手持剑
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local rootPart = humanoid and humanoid.RootPart
	if not (character and humanoid and rootPart) or humanoid.Health <= 0 then
		return
	end
	local sword = character:FindFirstChild(SWORD_NAME)
	if not (sword and sword:IsA("Tool")) then
		return
	end
	lastSwing[player] = now

	-- 3. 服务器自己的攻击判定框:攻击者根部零件前方的一个盒子
	local params = OverlapParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { character }
	local boxCFrame = rootPart.CFrame * CFrame.new(0, 0, -HIT_RANGE / 2)
	local parts = workspace:GetPartBoundsInBox(boxCFrame, Vector3.new(HIT_WIDTH, HIT_HEIGHT, HIT_RANGE), params)

	-- 4. 盒子里的每个 Humanoid 只受到一次伤害,即使它有多个零件在里面
	local alreadyHit: { [Humanoid]: boolean } = {}
	for _, part in parts do
		local model = part:FindFirstAncestorOfClass("Model")
		local target = model and model:FindFirstChildOfClass("Humanoid")
		if model and target and not alreadyHit[target] and target.Health > 0 then
			alreadyHit[target] = true
			if not isTeammate(player, Players:GetPlayerFromCharacter(model)) then
				target:TakeDamage(DAMAGE) -- 只要目标有 ForceField 就不起作用
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

Players.PlayerRemoving:Connect(function(player: Player)
	lastSwing[player] = nil
end)

SwordService 会在游戏启动时自己创建 RemoteEvent SwordSwing,所以不需要手动往 ReplicatedStorage 里插入任何东西。如果你已经创建了同名的 RemoteEvent,请删掉它:LocalScript 可能会找到你的那个,而服务器上没有人监听它。

SwordService 开头的设置
设置此处的值改变什么
SWORD_NAME"Sword"服务器期望在玩家手中的 Tool 的名字。如果你的 Tool 叫别的名字,就改掉它。
DAMAGE20每次命中扣除多少生命值。Humanoid 初始有 100 点生命值,所以五次命中会击倒测试骨架。玩家角色默认每秒恢复 MaxHealth 的 1%,所以以最快速度被攻击的玩家能挨过第五击,需要第六击。
COOLDOWN_SECONDS0.6两次挥砍之间的时间。在 SwordClient 中设置相同的值。
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6以 stud 为单位的攻击判定框:它在玩家前方能伸多远,有多宽、多高。
FRIENDLY_FIREfalse为 false 时,同队玩家不能互相伤害。没有队伍的玩家总是可以互相攻击,NPC 总是可以被攻击。
NETWORK_SLACK0.1服务器在冷却结束前多早仍然接受挥砍。两次间隔 0.6 秒的点击经过网络延迟后可能到达得稍近一些,没有这个余量,服务器就会丢掉玩家已经看到的真实挥砍。

第 3 步:在 Tool 中添加 LocalScript

在 Tool Sword 中插入一个 LocalScript,命名为 SwordClient,并粘贴以下代码:

LocalScript 位置: StarterPack 中的 Tool Sword 名称: SwordClient
-- Tool Sword 内部名为 SwordClient 的 LocalScript。
-- Tool.Activated 在玩家的设备上触发,所以这个脚本监听点击、
-- 轻触或扳机,播放挥砍动画,并请求服务器执行挥砍。

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local tool = script.Parent :: Tool
local swingEvent = ReplicatedStorage:WaitForChild("SwordSwing") :: RemoteEvent

local COOLDOWN_SECONDS = 0.6 -- 与 SwordService 中的值相同
local SWING_ANIMATION_ID = "" -- 可选:"rbxassetid://" 加上你的动画 id

local player = Players.LocalPlayer
local lastSwing = 0
local swingTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil

-- 每个角色只加载一次动画。在你自己的设备上对你自己的
-- 角色播放的动画,所有玩家都能看到。
local function loadSwing()
	local character = player.Character
	if SWING_ANIMATION_ID == "" or not character or character == trackCharacter then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
	if animator then
		local animation = Instance.new("Animation")
		animation.AnimationId = SWING_ANIMATION_ID
		swingTrack = animator:LoadAnimation(animation)
		trackCharacter = character
	end
end

tool.Equipped:Connect(loadSwing)

tool.Activated:Connect(function()
	local now = os.clock()
	if now - lastSwing < COOLDOWN_SECONDS then
		return -- 服务器也会检查;这里的检查可以省去多余的请求
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

暂时把 SWING_ANIMATION_ID 留空。没有动画剑也能用,因为命中无论如何都由服务器决定。如何填写它,见添加挥砍动画一节。

Activated 会在鼠标点击、手机轻触和手柄扳机时触发,所以同一个脚本在任何设备上都能用。玩家角色重生时,Roblox 会把 Tool 及其中的 LocalScript 复制到每个玩家的 Backpack,所以每个玩家运行的是自己的那一份。

LocalScript 保留自己的冷却时间,只是为了不发送服务器反正会忽略的请求。这不是安全检查:作弊者可以删除它、修改它,或者从自己的代码中触发 SwordSwing。RemoteEvent 教程解释了为什么每个 remote 都必须在服务器上检查,而 Script vs LocalScript vs ModuleScript(英文)说明了 LocalScript 能改变什么、不能改变什么。

服务器如何决定谁被击中

当 SwordSwing 到达时,SwordService 不向客户端询问任何东西。它在服务器看到的攻击者角色位置前方建一个盒子,并通过 workspace:GetPartBoundsInBox 询问引擎里面有哪些零件。这个方法取代了 Roblox 标记为已弃用的旧方法 FindPartsInRegion3。

盒子的中心在攻击者根部零件前方 3 个 stud 处。这就是偏移 CFrame.new(0, 0, -HIT_RANGE / 2):CFrame 朝向它的负 Z 轴,也就是它的 LookVector。所以盒子从角色中间向前伸出 6 个 stud,宽 5 个 stud,高 6 个 stud。这个查询比较的是每个零件的包围盒(bounding box),即对其体积的一种快速盒形近似,所以圆形零件和网格会被算得比看起来稍大一些。对剑来说,这点余量是有好处的。

SwordService 如何处理盒子里的零件
步骤代码原因
跳过攻击者带 Exclude 和攻击者角色的 OverlapParams攻击者自己的手臂、腿和剑也在盒子里。
找到角色part:FindFirstAncestorOfClass("Model")盒子里的零件可能是肢体、帽子或手里的工具。FindFirstAncestorOfClass 比较的是确切的类名,所以会越过帽子(Accessory 类)和手里的工具(Tool 类,尽管 Tool 是 Model 的一种),停在角色模型上。
找到 Humanoidmodel:FindFirstChildOfClass("Humanoid")任何有 Humanoid 的东西都能被攻击:玩家、NPC 和测试假人。墙壁和地板会被跳过。
每个 Humanoid 一次alreadyHit 表盒子里通常有同一个角色的多个零件。没有这张表,每个零件都会重新造成一次伤害。
只攻击活着的目标target.Health > 0已经被击倒的角色不会再被攻击。
队伍isTeammateFRIENDLY_FIRE 为 false 时,跳过同队玩家。Neutral 属性为 true 的玩家没有队伍。
伤害target:TakeDamage(DAMAGE)降低 Health,除非目标受到 ForceField 保护。

alreadyHit 表在每次挥砍时重新创建,所以冷却结束后,下一次挥砍可以再次击中同一个玩家。这就是“每次挥砍每个目标一次”的规则,基于 Touched 的剑在这一点上总是很麻烦。

脚本使用 TakeDamage,而不是给 Health 赋值。Roblox 的参考文档说,当 Humanoid 受 ForceField 保护时,TakeDamage 不会影响它,而直接给 Health 赋值会无视 ForceField。在 SpawnLocation 上重生的玩家默认获得 10 秒的 ForceField(SpawnLocation 的 Duration),所以新加入的玩家在出现的瞬间不会被攻击。

剑的四种攻击判定方式对比

剑的教程主要在一点上有分歧:如何知道剑刃打中了什么。常见的答案有四种。它们的区别在于跟随剑刃的精确程度、给服务器带来多少工作量,以及作弊者能否伪造结果。

剑的攻击判定方式。“谁来决定”指的是其结果被采纳的那一方
方式工作原理谁来决定精度最适合
剑刃上的 Touched每当剑刃零件碰到角色时造成伤害攻击者的设备,它拥有自己的角色和剑跟随剑刃,但一次接触会触发多次不适合任何有其他玩家的游戏:攻击者的设备可以在任何地方触发它
玩家前方的盒子(本教程)每次挥砍在服务器上做一次 GetPartBoundsInBox 查询服务器固定的盒子,而不是剑刃的轨迹。网格按包围盒计算,所以稍微宽松大多数游戏:简单、开销小,没有东西可伪造
攻击判定零件上的 GetPartsInPart挥砍期间,用一个剑刃弧形的零件在服务器上查询服务器形状精确:Roblox 文档说它会做完整的几何检查,并建议在精度要求不高时使用盒子或球体查询,因为它们开销更小形状特殊的大型武器,例如镰刀的弧形
沿剑刃的射线检测挥砍的每一帧,从剑刃上的点向它们上一帧所在的位置发射短射线发射射线的那一方。在服务器上需要服务器知道剑刃在哪里紧密跟随动画挥砍精确轨迹很重要的游戏。社区的攻击判定模块就是这样工作的

盒子是正确的首选。每次挥砍只需一次查询,它从不依赖作弊者可能修改的动画,而且用三个数字就能轻松调整。当玩家抱怨攻击范围与盒子相差很大的武器命中感觉不对时,再换成合适形状的零件或沿剑刃的射线,并保持同样的规则:查询由服务器执行,伤害由服务器造成。

剑的预设:从匕首到双手剑

同一个 SwordService 通过五个设置就能做出差别很大的武器。这张表是一个起点,按 Rig Generator 生成的 100 Health 假人计算。“击倒用时”从第一次命中算起,假设每次挥砍都在冷却允许时立即命中。

常见近战武器的 SwordService 设置,以及击倒 100 Health 假人所需的命中次数和用时。为计算值,而非实测
武器DAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTH命中次数(用时)每秒伤害
匕首120.35449(2.8 秒)约 34
剑(本教程)200.6655(2.4 秒)约 33
双手剑351.1773(2.2 秒)约 32
长矛180.8936(4 秒)约 23
  • 玩家会回血,假人不会。玩家角色默认每秒恢复 MaxHealth 的 1%。5 次命中恰好 100 点伤害时,以最快速度被攻击的玩家能挨过第五击,需要第六击。如果确切的命中次数很重要,请留出余量,例如用 21 点伤害代替 20 点。
  • 让 NETWORK_SLACK 随冷却时间等比例调整。教程中的 0.1 秒是 0.6 的六分之一。如果冷却 0.35 秒的匕首仍用 0.1,作弊者就能每 0.25 秒攻击一次,快 40%。取 COOLDOWN_SECONDS 的大约六分之一:匕首用 0.06。
  • 让 SwordClient 保持一致。在那里设置相同的 COOLDOWN_SECONDS,否则客户端会发送服务器忽略的挥砍。

第 2 版:前摇,并且不能穿墙攻击

基础版的剑能用之后,会出现两种抱怨。玩家点击的那一刻就命中了,早于挥砍动画碰到目标;而且挥砍能打到薄墙另一边的人,因为盒子不考虑墙壁。这个版本的 SwordService 把两者都修好了。它替换第 2 步的脚本:同样的名字、同样的 remote、同样的设置,所以 SwordClient 不需要修改。

Script 位置: ServerScriptService 名称: SwordService
-- ServerScriptService 中名为 SwordService 的 Script(带前摇和穿墙检查的版本)。
-- 替换第 2 步的脚本:同样的设置和 remote,再加两条规则。命中发生在
-- 点击后 WINDUP_SECONDS,也就是挥砍碰到目标的时候,并且不会隔着
-- 墙打到任何人。

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- 设置
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- 在 SwordClient 中保持相同的值
local WINDUP_SECONDS = 0.15 -- 从点击到命中的时间;按你的挥砍动画调整
local HIT_RANGE = 6
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false
local NETWORK_SLACK = 0.1

local swingEvent = Instance.new("RemoteEvent")
swingEvent.Name = "SwordSwing"
swingEvent.Parent = ReplicatedStorage

local lastSwing: { [Player]: number } = {}

local function isTeammate(attacker: Player, target: Player?): boolean
	if FRIENDLY_FIRE or not target then
		return false
	end
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

-- 当攻击者活着并手持剑时,返回他的角色和根部零件
local function getArmedCharacter(player: Player): (Model?, BasePart?)
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local rootPart = humanoid and humanoid.RootPart
	if not (character and humanoid and rootPart) or humanoid.Health <= 0 then
		return nil, nil
	end
	local sword = character:FindFirstChild(SWORD_NAME)
	if not (sword and sword:IsA("Tool")) then
		return nil, nil
	end
	return character, rootPart
end

-- 当攻击者和目标之间除了目标本身没有任何东西时返回 True
local function hasClearLine(attacker: Model, from: BasePart, target: Model, to: BasePart): boolean
	local params = RaycastParams.new()
	params.ExcludeInstances = { attacker }
	local result = workspace:Raycast(from.Position, to.Position - from.Position, params)
	return result == nil or result.Instance:IsDescendantOf(target)
end

local function strike(player: Player)
	-- 前摇之后再检查一次:攻击者可能已经死了或收起了剑
	local character, rootPart = getArmedCharacter(player)
	if not (character and rootPart) then
		return
	end
	local params = OverlapParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { character }
	local boxCFrame = rootPart.CFrame * CFrame.new(0, 0, -HIT_RANGE / 2)
	local parts = workspace:GetPartBoundsInBox(boxCFrame, Vector3.new(HIT_WIDTH, HIT_HEIGHT, HIT_RANGE), params)

	local alreadyHit: { [Humanoid]: boolean } = {}
	for _, part in parts do
		local model = part:FindFirstAncestorOfClass("Model")
		local target = model and model:FindFirstChildOfClass("Humanoid")
		local targetRoot = target and target.RootPart
		if model and target and targetRoot and not alreadyHit[target] and target.Health > 0 then
			alreadyHit[target] = true
			if not isTeammate(player, Players:GetPlayerFromCharacter(model)) and hasClearLine(character, rootPart, model, targetRoot) then
				target:TakeDamage(DAMAGE)
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(function(player: Player)
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end
	local character = getArmedCharacter(player)
	if not character then
		return
	end
	lastSwing[player] = now
	task.delay(WINDUP_SECONDS, strike, player)
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastSwing[player] = nil
end)

请先删除第 2 步的 SwordService,否则两个脚本会各自创建一个 SwordSwing remote。把 WINDUP_SECONDS 设为你的挥砍动画中剑刃经过角色前方的那一刻;快速挥砍用 0.15 就合适。

  • 前摇。冷却时间以及“活着并手持剑”的检查在点击到达时执行,然后 task.delay 在 WINDUP_SECONDS 之后启动 strike。strike 会再检查一次攻击者,因为这段时间里他可能已经死了或收起了剑,然后才建立盒子。在前摇期间走出攻击范围的目标不会被击中,这正是玩家看到挥砍时所期望的。
  • 穿墙检查。对盒子里的每个目标,hasClearLine 从攻击者的根部零件向目标的根部零件发射一条射线,跳过攻击者自己的角色。如果它遇到的第一个东西属于目标,或者什么都没遇到,命中就成立。两者之间的墙、门或另一个玩家会挡住它。
  • 开销。每次挥砍每个目标多一条射线,与盒子查询本身相比不算多。

前摇也让这把剑在面对“瞬移到某人身边的同时出手”的作弊者时更公平:服务器稍晚一点才寻找目标,依据的是它此刻看到的角色位置。这并不能阻止瞬移本身;那需要作弊者能做什么、不能做什么一节中描述的移动检查。

添加挥砍动画(可选)

只要你给 SwordClient 一个 ID,它就会播放动画。动画只需在 Studio 的 Animation Editor 中做一次:

  1. 插入一个用于制作动画的骨架。在 Avatar 或 Home 选项卡上点击 Character 打开 Rig Generator,选择与你游戏中的头像相符的骨架,例如 R15,再选 Block Avatar。
  2. 在 Avatar 选项卡上点击 Clip Editor 打开 Animation Editor,选中骨架,为一次短促的右手挥砍摆好姿势。
  3. 设置优先级为 Action:点击编辑器播放控件中的 … 按钮,把鼠标移到 Set Animation Priority 上,选择 Action。Action 高于 Movement、Idle 和 Core,所以挥砍会在行走和站立动画之上播放,而不会被它们盖过。
  4. 在同一个 … 菜单中选择 Publish to Roblox。如果你的游戏属于某个群组,提交前在 Creator 字段中选择这个群组。
  5. 从 Toolbox 复制动画的 asset ID,并在 SwordClient 中把 SWING_ANIMATION_ID 设为 "rbxassetid://" 加上这个数字。

SwordClient 通过角色的 Animator 加载挥砍动画,而不是通过 Roblox 标记为已弃用的旧方法 Humanoid:LoadAnimation。Roblox 的 Animator 参考文档说,玩家的设备在该玩家自己的角色上播放的动画会复制到服务器和所有其他玩家,所以 LocalScript 可以播放挥砍,所有人都能看到。文档还说 Animator 应该在服务器上创建,所以永远不要在 LocalScript 中创建它。玩家角色的 Animator 通常在 Humanoid 里面,Roblox 自己的动画示例也正是在那里查找它。

动画只是为了好看。命中不依赖它,所以缓慢、缺失或被修改的动画永远不会改变谁被击中。

如何按键、循环或在 NPC 身上播放动画,请阅读动画脚本教程。

旧的剑教程错在哪里

如果你在拿本教程和某个视频或论坛帖子对比,下面是重要的区别,以及每种做法会带来问题的原因。

剑教程中的常见做法,以及本教程用什么代替
教程的做法问题本教程
在剑刃的 Touched 事件中造成伤害攻击者的设备可以在任何地方触发自己剑上的 Touched(Roblox 关于 network ownership 的页面),而且一次接触会连续多次触发 Touched(Roblox 关于 debounce 的页面)。服务器用自己的盒子找出目标,每次挥砍每个 Humanoid 一次。
在 LocalScript 中降低 HealthLocalScript 对别人角色做的修改只留在这一台设备上。所有伤害都在 SwordService 中造成。
用 wait(0.5) 做冷却Roblox 把全局 wait() 标记为已弃用,改用 task.wait(),而且只存在于客户端的冷却拦不住任何人。在服务器上比较 os.clock() 时间。没有任何东西在等待。
通过 Humanoid:LoadAnimation 播放挥砍已弃用,改用 Animator:LoadAnimation。通过 Animator 加载挥砍动画。
通过 Region3 和 FindPartsInRegion3 寻找目标已弃用。Roblox 建议新项目使用带 OverlapParams 的 GetPartBoundsInBox。使用 GetPartBoundsInBox。
把服务端 Script 放进 Tool,让它监听 Activated每个玩家的剑都运行一份服务端代码,而且这类脚本常常在 Touched 中造成伤害(第一行)。在默认设置下,Script 只在 Workspace 或 ServerScriptService 中运行,所以 Tool 里的 Script 要到剑第一次被装备时才会运行。Roblox 关于工具的页面把大多数工具描述为:用于输入的 LocalScript、用于效果的服务端 Script,以及两者之间的 RemoteEvent。ServerScriptService 中的一个 SwordService 服务于游戏里所有的剑。

作弊者能做什么、不能做什么

假定作弊者控制着自己设备上的一切。他能读取和修改你的 LocalScript,而 Roblox 的安全指南说,他能以任意频率和任意参数触发 RemoteEvent。下面是这对这把剑意味着什么。

作弊者可能尝试什么,以及 SwordService 如何应对
作弊者尝试结果原因
以他的代码所能达到的最快速度触发 SwordSwing,或使用连点器每 0.5 秒最多只算一次挥砍服务器的冷却是 0.6 秒减去 0.1 秒的网络余量。这个余量就是作弊者能占到的最大便宜。
随 remote 发送目标、伤害数值或位置被忽略onSwing 只读取 Roblox 自己传入的玩家。随 remote 发送的其他任何东西都不会被读取。
修改 SwordClient,例如去掉它的冷却不影响服务器SwordService 把自己的设置放在 ServerScriptService 中,这里的内容从不会发送给玩家。
在死亡状态或手里没有剑时攻击被忽略SwordService 检查他的 Humanoid 是否活着,以及名为 Sword 的 Tool 是否在他的角色里,装备工具时 Roblox 会把它移到那里。
从地图另一头攻击某人什么都不会发生盒子是围绕服务器看到的攻击者角色位置建立的,只向前伸出 6 个 stud。
瞬移到玩家身边再攻击有可能每台设备控制自己角色的移动,Roblox 把瞬移到任意位置列为客户端能对自己角色做的事情之一。服务端的移动检查可以发现这一点。
隔着薄墙攻击在 6 个 stud 的盒子范围内有可能第 2 步的盒子查询不检查墙壁。第 2 版加入了穿墙检查。
播放任意动画或不播放动画不影响命中命中从不依赖动画。Roblox 指出,作弊者可以在自己的角色上播放任意动画。

有两行写着“有可能”,这是如实相告。这把剑不让作弊者选择打谁、打多重、打多频繁。但它无法阻止作弊者移动自己的角色。Roblox 的安全文档说,客户端控制自己角色的移动和物理,移动检查需要按每个游戏来调整。对于竞技类游戏,下一层防护是服务端的移动检查(冲刺教程里就搭了一个,它会对明显的加速外挂和远距离瞬移发出警告),或者 Roblox 的 server authority,在我们于 2026 年 10 月 13 日核对时,文档把它描述为测试版。

第 4 步:测试

  1. 添加一个可以攻击的东西。在 Avatar 或 Home 选项卡上点击 Character 打开 Rig Generator,选择一个骨架(例如 R15,然后 Block Avatar),它会被插入到 Workspace 中。把它挪到离你的 SpawnLocation 几个 stud 远的地方。
  2. 点击 Play,从快捷栏装备 Sword,走到骨架旁边并点击。第一次命中后,它头上会出现生命条,因为默认情况下 Humanoid 只有在 Health 低于 MaxHealth 时才显示生命条。Humanoid 初始有 100 点生命值,所以第五次命中会击倒它。
  3. 尽可能快地点击。每 0.6 秒只有一次挥砍会起作用。
  4. 离开骨架大约 8 个 stud,或者背对它挥砍。什么都不会发生,因为它没有任何零件在盒子里。
  5. 用真实玩家测试。在测试模式下拉列表中选择 Server & Clients,设置 2 个客户端,点击 Play。在另一个玩家重生后 10 秒内攻击他:因为重生时的 ForceField,什么都不会发生。之后每次命中扣除 20。默认情况下玩家角色还会每秒恢复 MaxHealth 的 1%,所以两次战斗之间他们的生命值会慢慢回升。
  6. 如果你的游戏有 Teams,把两个测试玩家放进同一个队伍。FRIENDLY_FIRE 为 false 时,他们的挥砍对彼此没有效果。

整个过程中保持 Output 窗口打开(Window 菜单,然后选 Output)。这些脚本正常工作时不会打印任何东西,所以来自 SwordService 或 SwordClient 的任何红色错误都是真正的问题。请看常见错误。

如何把剑扩展成战斗系统

连击

在服务器上,在 lastSwing 旁边为每个玩家保存一个挥砍计数器。如果上一次挥砍发生在不久前,就加 1;否则从 1 重新开始。然后按计数器选择伤害,例如每第三击伤害更高,并用同样的方式在 PlayerRemoving 时清除计数器。客户端可以自己计数来决定播放哪个动画,因为动画从不决定是否命中。盒子和各项检查保持完全一样。

击退

在 TakeDamage 之后,SwordService 可以通过对目标的 RootPart 调用 ApplyImpulse,沿攻击者的 rootPart.CFrame.LookVector 方向把目标推开。Roblox 的参考文档说,推力效果取决于目标的质量,服务端 Script 可以在服务器拥有的零件上调用它,也可以在客户端自动拥有的零件上调用。每个玩家的设备模拟自己的角色,所以请用 Server & Clients 在玩家身上测试击退,而不只是在骨架上。

为排行榜统计击杀

就在 target:TakeDamage(DAMAGE) 之前,用 target:SetAttribute("LastHitBy", player.UserId) 记下最后一击是谁打的。在服务端 Script 中连接每个角色 Humanoid 的 Died 事件,读取这个 Attribute,用 Players:GetPlayerByUserId 找到攻击者,并给他 leaderstats 中的 IntValue Kills 加 1。在 Coins 和 Wins 旁边创建它,就像排行榜教程的第 1 步那样,并像第 2 步那样在服务器上修改它。

格挡

添加第二个 RemoteEvent,客户端在格挡键按下和松开时触发它,由服务器在该玩家的角色上设置 Blocking Attribute,并有自己的频率限制。在 SwordService 中,当目标角色设置了 Blocking 时降低或跳过伤害。作弊者仍然可以自己决定何时格挡,所以让格挡持续时间短一些,或者给它加冷却。

出售剑,或在每回合发放

StarterPack 会在每次重生时把剑发给每个玩家。如果想改为出售,把它放进商店 GUI 教程中的 ShopItems 文件夹。那篇教程的商品目录已经在出售一个名为 ClassicSword 的 Tool,所以要么把这个 Tool 命名为 ClassicSword 并设置相同的 SWORD_NAME,要么修改目录里的条目。如果只想在回合期间发放,使用回合系统教程中的 GiveRoundTool 脚本:把 Sword 放在 ServerStorage 而不是 StarterPack,并把那个脚本中的 "RoundTool" 换成 "Sword"。

战斗用的敌人和远程武器

想要追逐玩家的 NPC,请按照 NPC 寻路教程来做。剑对它造成伤害,就像对其他任何 Humanoid 一样。关于按同样的服务端规则远距离攻击的武器,请阅读枪械教程。

常见错误与解决办法

在点击 Play 之前打开 Output 窗口(Window 菜单,然后选 Output)。剑的大多数问题要么会在那里打印错误,要么是因为名字对不上。

Infinite yield possible on 'ReplicatedStorage:WaitForChild("SwordSwing")'

SwordClient 在等待 SwordService 创建的 remote,说明 SwordService 没有运行。确认它是 Script 而不是 LocalScript,直接放在 ServerScriptService 中,没有被禁用,并且 Output 中没有来自它的错误。

我挥砍了,但没有人受到伤害

按顺序检查:SwordClient 是 LocalScript 而不是 Script,并且直接放在 Tool Sword 中;Tool 的名字正好是 Sword,或者与 SWORD_NAME 中写的一致;目标在你前方 6 个 stud 以内;目标重生已超过 10 秒,所以它的 ForceField 已经消失;如果你使用 Teams,在 FRIENDLY_FIRE 为 false 时你们不在同一个队伍。

剑能打到玩家,却从来打不到我的 NPC

像 GetPartBoundsInBox 这样的空间查询永远不会返回关闭了 CanQuery 的零件(CanQuery 只有在 CanCollide 也关闭时才生效)。把 NPC 身体部位的 CanQuery 重新打开,并确认它的 Humanoid 是 NPC 模型的直接子对象。

装备剑时我的角色被卡住了

剑的某个零件被锚固了。选中 Tool 里的所有零件,取消 Anchored。

同样的距离,有的挥砍命中,有的落空

在带前摇的版本中,在 WINDUP_SECONDS 内走出盒子的目标不会被击中,而穿墙检查会跳过站在墙后或另一个玩家身后的所有人。如果试玩测试中的落空让人觉得不公平,就缩短前摇或增大 HIT_WIDTH。

角色握住的是剑刃

名为 Handle 的零件不止一个,Roblox 选错了。只保留一个 Handle,也就是剑柄,把其他的改名。如果角度仍然不对,再调整 Tool 的握持属性。

装备剑时剑刃留在原地或掉下去

剑刃没有焊接到 Handle 上。添加一个 WeldConstraint,它的 Part0 为 Handle,Part1 为剑刃。

我的屏幕上能看到伤害,但另一个玩家的生命值没有变化

伤害是从 LocalScript 造成的,它只改变你那一份游戏。只在 SwordService 中造成伤害,就像第 2 步那样。

用 RoCode 来做

如果不想手动搭建这一切,RoCode 可以在你打开的场景里完成。它是一个独立的 AI 编程代理,不是 Roblox 出品:你在它的网页聊天中描述功能,它的 Roblox Studio 插件就会在你的 Explorer 中创建 Tool、零件和脚本,你不需要从聊天窗口复制代码。

你输入

做一把剑:StarterPack 中名为 Sword 的 Tool,带 Handle 和焊接在上面的剑刃;一个在 Activated 时触发 RemoteEvent 的 LocalScript;以及一个服务端 Script,检查 0.6 秒的冷却,并对玩家前方盒子里的所有 Humanoid 造成 20 点伤害。

RoCode 的操作
  • 用 Create Instance 创建 Tool 及其零件,并用 Set Property 设置它们的属性
  • 用 Create Script 编写 SwordService 和 SwordClient,并可以先用 Search Scripts 查找已有的战斗脚本
  • 它被要求用 Check Script 检查自己写的每个脚本能否编译,Check Script 在 Studio 中编译代码而不运行(它不做类型检查)
  • 在每批修改前后设置撤销点,所以 Ctrl+Z 每次回退一批

RoCode 无法制作或上传挥砍动画:请在 Animation Editor 中制作并粘贴它的 ID。在插件 3.9 及以上,RoCode 可以运行简短的试玩测试并读取错误;在插件 3.9.11 及以上,它可以操控测试角色,但它不会在 3D 窗口中点击来挥砍,所以挥砍需要你自己测试。如何用 RoCode 一个系统一个系统地做出完整的 Roblox 游戏一文展示了武器放在哪个环节。RoCode 如何连接到 Studio。

常见问题

为什么我的剑一次挥砍会多次击中同一个玩家?

因为它在 Touched 中造成伤害。Roblox 关于 debounce 的页面指出,一次接触会连续多次触发 Touched,而目标的每个零件都可能碰到剑刃。本教程每次挥砍用一次盒子查询找出目标,并维护一个列表,所以每个 Humanoid 每次挥砍只掉一次生命值。

剑的伤害应该写在 LocalScript 还是 Script 里?

写在服务器上的 Script 里。从 LocalScript 造成的伤害只改变这个玩家那一份游戏,而玩家设备上的任何东西作弊者都能修改。LocalScript 只应该感知点击、播放动画并触发 RemoteEvent。

怎么给剑加挥砍动画?

在 Animation Editor 中制作,设置优先级为 Action,发布到 Roblox,并把它的 asset ID 以 rbxassetid:// 加数字的形式写进 SWING_ANIMATION_ID。SwordClient 通过角色的 Animator 播放它。玩家的设备在该玩家自己的角色上播放的动画,所有人都能看到。

为什么剑的动画不播放?

检查三件事。优先级:Action 高于 Movement、Idle 和 Core,所以 Action 的挥砍会在行走和站立之上播放,而较低的优先级可能会被它们盖过。所有者:如果游戏属于群组,发布动画时要选择这个群组作为 Creator。ID:SWING_ANIMATION_ID 必须是带你的动画数字的完整 rbxassetid:// 文本,而不是空字符串。

Roblox 里剑用哪种攻击判定最好?

对大多数游戏来说,是像本教程这样每次挥砍在服务器上做一次盒子查询:一次 GetPartBoundsInBox 调用,客户端没有东西可伪造,只需调整三个数字。只有当武器的攻击范围与盒子相差很大时,才使用带合适形状零件的 GetPartsInPart 或沿剑刃的射线检测。四种方式的对比。

怎么让剑不能穿墙攻击?

造成伤害之前,从攻击者的根部零件向目标的根部零件发射一条射线,跳过攻击者的角色,只有当射线遇到的第一个东西属于目标时才算命中。SwordService 第 2 版会对每个目标这样做。

为什么挥砍动画还没碰到目标就命中了?

服务器在点击到达的那一刻就检查攻击判定框。先等待一个短暂的前摇,例如通过 task.delay 等 0.15 秒,然后检查攻击者是否仍然活着并手持剑,再建立盒子,就像第 2 版那样。

作弊者还能用这把剑作弊吗?

他们无法选择打谁、一次打多少伤害、多久打一次,因为这三件事都由服务器决定;他们最多能占到冷却上 0.1 秒网络余量的便宜。他们仍然可以移动自己的角色,例如贴到某人身边,因为每台设备控制自己角色的移动。下一层防护是服务端的移动检查。

怎么做带连击的战斗系统?

在服务器上为每个玩家保存一个挥砍计数器,短暂停顿后重置,并按计数器选择伤害和动画。命中检查保持不变。如何扩展一节还讲了击退、击杀统计和格挡。

参考资料

代码如何验证:本页的所有脚本都已用 Roblox API 类型定义(luau-lsp,2026年11月20日)通过 Luau strict 类型检查。类型检查能发现 API 名称写错和类型不匹配,但发现不了游戏逻辑上的错误。发布前请务必在 Studio 中测试。

在你自己的游戏里试试 RoCode。

每天有免费额度,无需绑定银行卡。安装插件,描述你想要的功能,然后看看它在 Studio 里做了什么。