Tutoriel · Systèmes de jeu

Comment faire une épée sur Roblox Studio

Une épée sur Roblox est un Tool avec trois tâches réparties sur deux scripts : l'appareil du joueur remarque le clic et joue le coup, et le serveur décide qui a été touché et combien de vie il perd. Ce guide construit les deux, avec un cooldown et une hitbox que les joueurs ne peuvent pas falsifier, et montre où placer une animation.

Mis à jour le 12 novembre 202626 min de lectureÉcrit par

En bref

Mets un Tool nommé Sword avec une part nommée Handle dans StarterPack. Un LocalScript dans le Tool écoute Tool.Activated, joue l'animation du coup et déclenche un RemoteEvent sans argument. Un Script dans ServerScriptService vérifie le cooldown et que le joueur est en vie et tient l'épée, trouve les Humanoids dans une boîte devant lui avec workspace:GetPartBoundsInBox, et appelle Humanoid:TakeDamage une fois par cible.

  • N'inflige pas les dégâts depuis l'événement Touched de la lame : l'appareil du joueur contrôle son propre personnage et peut déclencher Touched de n'importe où, et c'est justement l'exemple de l'épée que donne la page de Roblox sur la propriété réseau.
  • Le client n'envoie ni cible ni dégâts. Le cooldown, la hitbox et le montant des dégâts appartiennent au serveur.
  • TakeDamage ne fait rien tant que la cible a un ForceField, comme pendant les 10 secondes qui suivent l'apparition sur une SpawnLocation.
  • Des coups à travers les murs, ou qui portent avant que le coup ait l'air de toucher ? Utilise la version avec élan et test de mur du script serveur.
Sur cette page
  1. Fonctionnement
  2. 1. Construire le Tool
  3. 2. Script serveur
  4. 3. LocalScript
  5. La hitbox
  6. Méthodes de hitbox
  7. Élan et test de mur
  8. Animation du coup
  9. Anciens tutoriels
  10. Limites face aux exploits
  11. 4. Tester
  12. Aller plus loin
  13. Problèmes courants
  14. Avec RoCode
  15. Questions fréquentes
  16. Sources et lectures

Comment s'assemble une épée qui marche

Illustration animéeLes coups espacés d'au moins 0,6 seconde retirent 20 de vie chacun, un clic pendant le cooldown ne fait rien, et le cinquième coup met le rig K.-O.

Une épée qui marche dans un jeu en ligne est répartie entre l'appareil du joueur et le serveur. La page de Roblox sur les tools dit que les entrées d'un tool vont dans des LocalScripts, parce que seul l'appareil du joueur sait quand une entrée a lieu, et que la plupart des tools ont besoin d'un LocalScript, d'un Script serveur et d'un RemoteEvent entre les deux. Ce guide utilise exactement cette répartition. Un coup se passe comme ça :

  1. Le joueur clique, touche l'écran ou appuie sur la gâchette de la manette avec la Sword équipée. Tool.Activated se déclenche dans le LocalScript.
  2. Le LocalScript joue l'animation du coup, s'il y en a une, et déclenche le RemoteEvent SwordSwing. Il n'envoie rien d'autre.
  3. Le Script serveur vérifie le cooldown, que le joueur est en vie et que la Sword est dans sa main.
  4. Le serveur construit sa propre hitbox devant le personnage du joueur et trouve chaque Humanoid qui s'y trouve.
  5. Chacun de ces Humanoids perd de la vie une fois, par TakeDamage.
Les éléments de l'épée
ÉlémentOù il se trouveCe qu'il fait
Le Tool SwordStarterPackCe que tient le joueur. Roblox copie tout le contenu de StarterPack dans le Backpack du joueur à chaque apparition de son personnage.
La Part HandleDans le ToolLa part que le personnage tient en main. La lame y est soudée.
Le LocalScript SwordClientDans le ToolEntend le clic, joue l'animation du coup et déclenche le remote.
Le RemoteEvent SwordSwingReplicatedStorage (SwordService le crée)Transporte "j'ai donné un coup" de l'appareil du joueur au serveur, sans argument.
Le Script SwordServiceServerScriptServiceVérifie chaque coup, trouve qui est devant le joueur et inflige les dégâts. Le seul endroit où un coup peut porter.
L'Explorer une fois l'épée terminée. SwordService ajoute un RemoteEvent nommé SwordSwing dans ReplicatedStorage quand le jeu tourne.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

Étape 1 : construire le Tool de l'épée

  1. Dans l'Explorer, survole Workspace, clique sur le bouton + et insère un Tool. Renomme-le Sword. Le script serveur cherche ce nom exact. Tu construis l'épée dans Workspace, comme le conseille la page de Roblox sur les tools, parce que c'est là que tu peux voir ses parts, les déplacer et les redimensionner. La dernière étape la déplace dans StarterPack.
  2. Insère une Part dans le Tool et nomme-la Handle. C'est la poignée, là où le personnage tient l'épée. Elle doit être un enfant direct du Tool, et elle doit être la seule part de ce nom : avec deux Handles, Roblox en choisit une au hasard, et le personnage risque de tenir l'épée par la lame.
  3. Insère une deuxième Part dans le Tool, nomme-la Blade, et donne-lui une forme et une position telles qu'elle dépasse du haut de la Handle.
  4. Insère une WeldConstraint dans Blade. Dans la fenêtre Properties, règle sa Part0 sur Handle et sa Part1 sur Blade, pour que l'épée reste en un seul morceau quand le joueur la porte.
  5. Sélectionne les deux parts et vérifie que Anchored est décoché. Une part ancrée dans un tool cloue le personnage sur place quand il l'équipe. Désactive aussi CanCollide sur les deux, pour que la lame ne cogne pas les joueurs et les murs quand tu frappes.
  6. Sélectionne le Tool et décoche CanBeDropped. Quand c'est coché, appuyer sur Retour arrière lâche l'épée dans Workspace.
  7. Fais glisser la Sword terminée de Workspace vers StarterPack. Un Tool laissé dans Workspace est un objet à ramasser qu'un seul joueur récupère, pas une épée qui commence dans le Backpack de chaque joueur.

Une épée faite d'un seul MeshPart marche aussi : nomme ce MeshPart Handle et saute la soudure. Si le personnage tient l'épée avec un angle bizarre quand tu testes, sélectionne le Tool et ajuste ses propriétés de prise (GripPos, GripForward, GripRight et GripUp) dans la fenêtre Properties.

Étape 2 : ajouter le script serveur

Survole ServerScriptService, insère un Script nommé SwordService et colle le code ci-dessous. C'est le seul endroit où un coup d'épée peut porter. Les réglages du haut sont les lignes que tu es censé changer.

Script dans ServerScriptService nommé SwordService
-- Script dans ServerScriptService nommé SwordService.
-- Le seul endroit où un coup d'épée peut porter : il vérifie le coup, trouve les cibles devant
-- l'attaquant avec sa propre hitbox, et inflige les dégâts.

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

-- Réglages
local SWORD_NAME = "Sword" -- le nom du Tool dans StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- garde la même valeur dans SwordClient
local HIT_RANGE = 6 -- studs devant l'attaquant
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false : les joueurs de la même équipe ne peuvent pas se blesser
-- Des coups envoyés à exactement COOLDOWN_SECONDS d'écart peuvent arriver un peu plus rapprochés après un
-- délai réseau, donc le serveur accepte cette marge au lieu de jeter un vrai coup
local NETWORK_SLACK = 0.1

-- Le remote que déclenche le LocalScript de l'épée. Il ne transporte aucun argument : le serveur
-- décide qui est touché, donc un client n'a rien à falsifier.
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
	-- Les joueurs neutres (sans équipe) peuvent toujours se frapper
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. Un coup par cooldown, quelle que soit la fréquence à laquelle le remote est déclenché
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. L'attaquant doit être en vie et tenir l'épée
	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. La hitbox du serveur lui-même : une boîte devant la part racine de l'attaquant
	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. Blesse une fois chaque Humanoid de la boîte, même si plusieurs de ses parts sont dedans
	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) -- ne fait rien tant que la cible a un ForceField
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

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

SwordService crée lui-même le RemoteEvent SwordSwing au démarrage du jeu, donc il n'y a rien à insérer à la main dans ReplicatedStorage. Si tu as déjà créé un RemoteEvent avec ce nom, supprime-le : le LocalScript pourrait trouver le tien, que rien n'écoute sur le serveur.

Les réglages en haut de SwordService
RéglageValeur iciCe qu'il change
SWORD_NAME"Sword"Le nom du Tool que le serveur attend dans la main du joueur. Change-le si ton Tool porte un autre nom.
DAMAGE20La vie que retire chaque coup. Un Humanoid commence avec 100 de vie, donc cinq coups mettent le rig de test K.-O. Les personnages des joueurs regagnent par défaut 1 % de leur MaxHealth chaque seconde, donc un joueur frappé à la cadence maximale survit au cinquième coup et en demande un sixième.
COOLDOWN_SECONDS0.6Le temps entre deux coups. Mets la même valeur dans SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6La hitbox en studs : jusqu'où elle porte devant le joueur, sa largeur et sa hauteur.
FRIENDLY_FIREfalseSur false, les joueurs de la même équipe ne peuvent pas se blesser. Les joueurs sans équipe peuvent toujours se frapper, et les PNJ peuvent toujours être touchés.
NETWORK_SLACK0.1De combien le serveur accepte encore un coup avant la fin du cooldown. Deux clics espacés de 0,6 seconde peuvent arriver un peu plus rapprochés après un délai réseau, et sans cette marge le serveur jetterait un vrai coup que le joueur a déjà vu.

Étape 3 : ajouter le LocalScript dans le Tool

Insère un LocalScript dans le Tool Sword, nomme-le SwordClient et colle ceci dedans :

LocalScript dans le Tool Sword dans StarterPack nommé SwordClient
-- LocalScript dans le Tool Sword, nommé SwordClient.
-- Tool.Activated se déclenche sur l'appareil du joueur, donc ce script écoute le clic,
-- l'appui ou la gâchette, joue l'animation du coup et demande au serveur de frapper.

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 -- la même valeur que dans SwordService
local SWING_ANIMATION_ID = "" -- facultatif : "rbxassetid://" suivi de l'id de ton animation

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

-- Charge l'animation une fois par personnage. Les animations lancées sur ton propre personnage
-- depuis ton appareil sont montrées à tous les joueurs.
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 -- le serveur l'impose aussi ; vérifier ici évite des demandes inutiles
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

Laisse SWING_ANIMATION_ID vide pour l'instant. L'épée marche sans animation, parce que le serveur décide du coup dans tous les cas. Ajouter une animation de coup montre comment le remplir.

Activated se déclenche pour un clic de souris, un appui sur un téléphone et la gâchette d'une manette, donc le même script marche sur tous les appareils. Roblox copie le Tool, et le LocalScript qu'il contient, dans le Backpack de chaque joueur quand son personnage apparaît, donc chaque joueur fait tourner sa propre copie.

Le LocalScript ne garde son propre cooldown que pour éviter d'envoyer des demandes que le serveur ignorerait de toute façon. Ce n'est pas une vérification de sécurité : un tricheur peut le supprimer, le modifier ou déclencher SwordSwing depuis son propre code. Le guide des RemoteEvents explique pourquoi chaque remote doit être vérifié sur le serveur, et Script vs LocalScript vs ModuleScript (en anglais) montre ce qu'un LocalScript peut changer et ce qu'il ne peut pas.

Comment le serveur décide qui est touché

Quand SwordSwing arrive, SwordService ne demande rien au client. Il construit une boîte devant le personnage de l'attaquant, là où le serveur le voit, et demande au moteur quelles parts sont dedans avec workspace:GetPartBoundsInBox. Cette méthode remplace l'ancien FindPartsInRegion3, que Roblox marque comme obsolète.

La boîte est centrée 3 studs devant la part racine de l'attaquant. C'est le décalage CFrame.new(0, 0, -HIT_RANGE / 2) : un CFrame regarde le long de son axe Z négatif, son LookVector. La boîte va donc du milieu du personnage jusqu'à 6 studs devant, et elle fait 5 studs de large et 6 studs de haut. La requête compare la boîte englobante de chaque part, une approximation rapide en forme de boîte de son volume, donc les parts rondes et les meshes comptent comme un peu plus gros qu'ils n'en ont l'air. Pour une épée, cette petite marge aide.

Ce que SwordService fait des parts de la boîte
ÉtapeCodePourquoi
Ignorer l'attaquantOverlapParams avec Exclude et le personnage de l'attaquantLes bras, les jambes et l'épée de l'attaquant sont dans la boîte aussi.
Trouver le personnagepart:FindFirstAncestorOfClass("Model")Une part de la boîte peut être un membre, un chapeau ou un tool tenu en main. FindFirstAncestorOfClass compare le nom exact de la classe, donc il passe par-dessus un chapeau (classe Accessory) et un tool tenu (classe Tool, même si un Tool est une sorte de Model) et s'arrête au modèle du personnage.
Trouver le Humanoidmodel:FindFirstChildOfClass("Humanoid")Tout ce qui a un Humanoid peut être touché : joueurs, PNJ et mannequins de test. Les murs et les sols sont ignorés.
Une fois par Humanoidla table alreadyHitPlusieurs parts d'un même personnage sont en général dans la boîte. Sans la table, chacune infligerait les dégâts de nouveau.
Seulement les cibles en vietarget.Health > 0Un personnage déjà K.-O. n'est pas touché de nouveau.
Les équipesisTeammateAvec FRIENDLY_FIRE sur false, les joueurs de la même équipe sont ignorés. Un joueur dont la propriété Neutral vaut true n'a pas d'équipe.
Les dégâtstarget:TakeDamage(DAMAGE)Baisse Health sauf si un ForceField protège la cible.

La table alreadyHit est recréée à chaque coup, donc le même joueur peut être touché de nouveau au coup suivant une fois le cooldown passé. C'est la règle "une fois par cible et par coup" avec laquelle les épées basées sur Touched ont du mal.

Le script utilise TakeDamage plutôt que de régler Health. La référence de Roblox dit que TakeDamage laisse un Humanoid tranquille tant qu'un ForceField le protège, et que régler Health directement ignore les ForceFields. Un joueur qui apparaît sur une SpawnLocation reçoit par défaut un ForceField pendant 10 secondes (la Duration de la SpawnLocation), donc les nouveaux arrivants ne peuvent pas être frappés à l'instant où ils apparaissent.

Quatre façons de faire une hitbox d'épée, comparées

Les tutoriels d'épée sont surtout en désaccord sur un point : comment savoir ce que la lame a touché. Il y a quatre réponses courantes. Elles diffèrent par la précision avec laquelle elles suivent la lame, par le travail qu'elles coûtent au serveur, et par la possibilité pour un tricheur de falsifier le résultat.

Méthodes de hitbox d'épée. "Qui décide" est le côté dont la réponse compte
MéthodeComment ça marcheQui décidePrécisionIdéal pour
Touched sur la lameDes dégâts chaque fois que la part de la lame touche un personnageL'appareil de l'attaquant, qui possède son propre personnage et son épéeSuit la lame, mais se déclenche plusieurs fois par contactRien dans un jeu avec d'autres joueurs : l'appareil de l'attaquant peut le déclencher de n'importe où
Une boîte devant le joueur (ce guide)Une requête GetPartBoundsInBox sur le serveur par coupLe serveurUne boîte fixe, pas la trajectoire de la lame. Les meshes comptent par leur boîte englobante, donc un peu généreuxLa plupart des jeux : simple, peu coûteux, et rien à falsifier
GetPartsInPart sur une part de hitboxUne requête côté serveur avec une part qui a la forme du balayage de la lame, pendant le coupLe serveurFormes exactes : la documentation de Roblox dit qu'il fait un test géométrique complet, et conseille les requêtes en boîte ou en sphère quand moins de précision suffit, parce qu'elles coûtent moins cherLes grosses armes aux formes inhabituelles, comme l'arc d'une faux
Des raycasts le long de la lameÀ chaque image du coup, lance de courts rayons depuis des points de la lame vers l'endroit où ils étaient à l'image précédenteLe côté qui les lance. Sur le serveur, il faut l'idée que le serveur se fait de la position de la lameSuit l'animation de prèsLes jeux où la trajectoire exacte du coup compte. Les modules de hitbox de la communauté marchent comme ça

La boîte est le bon premier choix. C'est une requête par coup, elle ne dépend jamais de l'animation qu'un tricheur pourrait changer, et elle se règle facilement avec trois nombres. Passe à une part avec une forme ou à des rayons de lame quand les joueurs se plaignent que les coups sonnent faux pour une arme dont la portée est loin d'une boîte, et garde la même règle : le serveur lance la requête et inflige les dégâts.

Préréglages d'épée : de la dague à l'espadon

Le même SwordService fait des armes très différentes à partir de cinq réglages. Le tableau est un point de départ, calculé contre un mannequin du Rig Generator avec 100 de Health. Le temps pour mettre K.-O. compte à partir du premier coup, chaque coup portant dès que le cooldown le permet.

Réglages de SwordService pour des armes de mêlée courantes, avec les coups et le temps pour mettre K.-O. un mannequin de 100 de Health. Calculé, pas mesuré
ArmeDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHCoups (temps)Dégâts par seconde
Dague120.35449 (2,8 s)environ 34
Épée (ce guide)200.6655 (2,4 s)environ 33
Espadon351.1773 (2,2 s)environ 32
Lance180.8936 (4 s)environ 23
  • Les joueurs se soignent, pas les mannequins. Les personnages des joueurs regagnent par défaut 1 % de leur MaxHealth chaque seconde. Avec exactement 100 de dégâts en 5 coups, un joueur frappé à pleine vitesse survit au cinquième coup et en demande un sixième. Laisse une marge, par exemple 21 de dégâts au lieu de 20, si un nombre de coups précis compte.
  • Adapte NETWORK_SLACK au cooldown. Le 0,1 seconde du guide est un sixième de 0,6. Laissé à 0,1 sur une dague à 0,35 seconde, un tricheur pourrait frapper toutes les 0,25 seconde, 40 % plus vite. Utilise environ un sixième de COOLDOWN_SECONDS : 0,06 pour la dague.
  • Garde SwordClient synchronisé. Mets-y le même COOLDOWN_SECONDS, sinon le client envoie des coups que le serveur ignore.

Version 2 : un élan et aucun coup à travers les murs

Deux plaintes reviennent une fois que l'épée de base marche. Le coup porte à l'instant où le joueur clique, avant que l'animation atteigne la cible, et un coup peut atteindre quelqu'un de l'autre côté d'un mur fin, parce que la boîte ignore les murs. Cette version de SwordService corrige les deux. Elle remplace le script de l'étape 2 : même nom, même remote, mêmes réglages, donc SwordClient n'a pas besoin de changer.

Script dans ServerScriptService nommé SwordService
-- Script dans ServerScriptService nommé SwordService (la version avec élan et test de mur).
-- Remplace le script de l'étape 2 : mêmes réglages et même remote, plus deux règles. Le coup porte
-- WINDUP_SECONDS après le clic, quand le coup atteint la cible, et personne n'est touché
-- à travers un mur.

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

-- Réglages
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- garde la même valeur dans SwordClient
local WINDUP_SECONDS = 0.15 -- temps entre le clic et le coup ; accorde-le à ton animation
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

-- Renvoie le personnage et la part racine de l'attaquant tant qu'il est en vie et tient l'épée
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 quand rien d'autre que la cible ne se trouve entre l'attaquant et la cible
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)
	-- Revérifié après l'élan : l'attaquant a pu mourir ou ranger l'épée
	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)

Supprime d'abord le SwordService de l'étape 2, sinon les deux scripts créent chacun un remote SwordSwing. Règle WINDUP_SECONDS sur le moment de ton animation où la lame passe devant le personnage ; 0.15 convient à un coup rapide.

  • L'élan. Le cooldown et les vérifications "en vie et tient l'épée" se font quand le clic arrive, puis task.delay lance strike WINDUP_SECONDS plus tard. strike revérifie l'attaquant, parce qu'il a pu mourir ou ranger l'épée entre-temps, et seulement ensuite construit la boîte. Une cible qui sort de portée pendant l'élan est manquée, et c'est ce que les joueurs attendent quand ils voient le coup.
  • Le test de mur. Pour chaque cible de la boîte, hasClearLine lance un rayon de la part racine de l'attaquant à la part racine de la cible, en ignorant le personnage de l'attaquant. Si la première chose qu'il rencontre appartient à la cible, ou s'il ne rencontre rien, le coup compte. Un mur, une porte ou un autre joueur entre les deux le bloque.
  • Ce que ça coûte. Un rayon en plus par cible et par coup, ce qui est peu à côté de la requête de la boîte elle-même.

L'élan rend aussi l'épée plus juste face aux tricheurs qui frappent à l'instant où ils se téléportent à côté de quelqu'un : le serveur cherche les cibles un instant plus tard, là où il voit les personnages à ce moment-là. Il n'empêche pas la téléportation elle-même ; pour ça, il faut la vérification des déplacements décrite dans Ce qu'un exploiteur peut faire et ne peut pas faire.

Ajouter une animation de coup (facultatif)

SwordClient joue déjà une animation dès que tu lui donnes un ID. Tu crées l'animation une seule fois, dans l'Animation Editor de Studio :

  1. Insère un rig à animer. Dans l'onglet Avatar ou Home, clique sur Character pour ouvrir le Rig Generator et choisis un rig qui correspond aux avatars de ton jeu, par exemple R15 puis Block Avatar.
  2. Dans l'onglet Avatar, clique sur Clip Editor pour ouvrir l'Animation Editor, sélectionne le rig, et pose un court coup du bras droit.
  3. Règle la priorité sur Action : clique sur le bouton … dans les commandes de lecture de l'éditeur, survole Set Animation Priority et choisis Action. Action passe au-dessus de Movement, Idle et Core, donc le coup se joue par-dessus les animations de marche et d'attente au lieu de perdre contre elles.
  4. Dans le même menu …, choisis Publish to Roblox. Si ton jeu appartient à un groupe, sélectionne ce groupe dans le champ Creator avant d'envoyer.
  5. Copie l'asset ID de l'animation depuis la Toolbox, et dans SwordClient règle SWING_ANIMATION_ID sur "rbxassetid://" suivi de ce nombre.

SwordClient charge le coup par l'Animator du personnage, pas par l'ancien Humanoid:LoadAnimation, que Roblox marque comme obsolète. La référence Animator de Roblox dit que les animations que l'appareil d'un joueur lance sur le personnage de ce joueur sont répliquées au serveur et à tous les autres joueurs, donc le LocalScript peut jouer le coup et tout le monde le voit. Elle dit aussi que l'Animator doit être créé sur le serveur, donc n'en crée jamais dans un LocalScript. Les personnages des joueurs en ont normalement un dans le Humanoid, et c'est là que l'exemple d'animation de Roblox le cherche.

L'animation n'est là que pour le spectacle. Les coups n'en dépendent pas, donc une animation lente, manquante ou modifiée ne change jamais qui est touché.

Pour jouer une animation sur une touche, en boucle ou sur un PNJ, vois le guide des scripts d'animation.

Les erreurs des anciens tutoriels d'épée

Si tu compares ce guide avec une vidéo ou un message de forum, voici les différences qui comptent, avec la raison pour laquelle chaque méthode pose problème.

Méthodes courantes des tutoriels d'épée, et ce que ce guide fait à la place
Le tutorielLe problèmeCe guide
Inflige les dégâts dans l'événement Touched de la lameL'appareil de l'attaquant peut déclencher Touched sur sa propre épée de n'importe où (page de Roblox sur la propriété réseau), et Touched se déclenche plusieurs fois de suite très vite pour un seul contact (page de Roblox sur le debounce).Le serveur trouve les cibles avec sa propre boîte, une fois par Humanoid et par coup.
Baisse Health dans un LocalScriptUn changement qu'un LocalScript fait sur un autre personnage reste sur ce seul appareil.Tous les dégâts se font dans SwordService.
Utilise wait(0.5) pour le cooldownRoblox marque le wait() global comme obsolète, remplacé par task.wait(), et un cooldown qui n'existe que sur le client n'arrête personne.Compare des heures os.clock() sur le serveur. Rien n'attend.
Joue le coup avec Humanoid:LoadAnimationObsolète, remplacé par Animator:LoadAnimation.Charge le coup par l'Animator.
Trouve les cibles avec Region3 et FindPartsInRegion3Obsolète. Roblox dit d'utiliser GetPartBoundsInBox avec OverlapParams pour tout nouveau travail.Utilise GetPartBoundsInBox.
Met dans le Tool un Script serveur qui écoute ActivatedL'épée de chaque joueur fait tourner sa propre copie du code serveur, et ces scripts infligent souvent les dégâts dans Touched (la première ligne). Avec les réglages par défaut, un Script ne tourne que sous Workspace ou ServerScriptService, donc un Script dans un Tool ne démarre pas tant que l'épée n'a pas été équipée une première fois. La page de Roblox sur les tools décrit la plupart des tools comme un LocalScript pour les entrées, un Script serveur pour l'effet et un RemoteEvent entre les deux.Un seul SwordService dans ServerScriptService gère toutes les épées du jeu.

Ce qu'un exploiteur peut faire et ne peut pas faire

Pars du principe qu'un tricheur contrôle tout sur son propre appareil. Il peut lire et modifier tes LocalScripts, et le guide de sécurité de Roblox dit qu'il peut déclencher des RemoteEvents à n'importe quelle fréquence avec des arguments arbitraires. Voici ce que ça veut dire pour cette épée.

Ce qu'un tricheur peut tenter, et ce que SwordService fait contre ça
Un tricheur essaie deRésultatPourquoi
Déclencher SwordSwing aussi vite que son code le peut, ou utiliser un auto-clickerAu plus un coup toutes les 0,5 seconde compteLe cooldown du serveur est de 0,6 seconde moins la marge réseau de 0,1 seconde. Cette marge est le maximum que gagne un tricheur.
Envoyer une cible, un nombre de dégâts ou une position avec le remoteIgnoréonSwing ne lit que le joueur, que Roblox remplit lui-même. Tout ce qui est envoyé d'autre avec le remote n'est jamais lu.
Modifier SwordClient, par exemple pour retirer son cooldownAucun effet sur le serveurSwordService garde ses propres réglages dans ServerScriptService, qui n'est jamais envoyé aux joueurs.
Frapper en étant mort, ou sans l'épée en mainIgnoréSwordService vérifie que son Humanoid est en vie et qu'un Tool nommé Sword est dans son personnage, là où Roblox déplace un tool quand il est équipé.
Toucher quelqu'un depuis l'autre bout de la carteRien ne se passeLa boîte est construite autour du personnage de l'attaquant, là où le serveur le voit, et ne porte qu'à 6 studs devant.
Se téléporter à côté d'un joueur, puis frapperPossibleChaque appareil contrôle les déplacements de son propre personnage, et Roblox cite la téléportation vers n'importe quelle position parmi ce qu'un client peut faire avec son propre personnage. Une vérification des déplacements côté serveur peut le signaler.
Frapper à travers un mur finPossible à l'intérieur de la boîte de 6 studsLa requête de boîte de l'étape 2 ne cherche pas les murs. La version 2 ajoute un test de mur.
Jouer n'importe quelle animation, ou aucuneAucun effet sur les coupsLes coups ne dépendent jamais de l'animation. Roblox note que les tricheurs peuvent jouer des animations arbitraires sur leur propre personnage.

Deux lignes disent "Possible", et c'est honnête. Cette épée empêche un tricheur de choisir qui il touche, avec quelle force et à quelle fréquence. Elle ne peut pas l'empêcher de déplacer son propre personnage. La documentation de sécurité de Roblox dit que les clients contrôlent les déplacements et la physique de leur personnage, et que les vérifications de déplacement doivent être ajustées à chaque jeu. Pour un jeu compétitif, une vérification des déplacements côté serveur est la couche suivante (le guide du sprint en construit une qui signale les speed hacks grossiers et les longues téléportations), ou bien la server authority de Roblox, que la documentation décrivait comme une bêta quand nous avons vérifié le 13 octobre 2026.

Étape 4 : tester

  1. Ajoute quelque chose à frapper. Dans l'onglet Avatar ou Home, clique sur Character pour ouvrir le Rig Generator, choisis un rig (par exemple R15, puis Block Avatar) et il est inséré dans Workspace. Déplace-le à quelques studs de ta SpawnLocation.
  2. Appuie sur Play, équipe la Sword depuis la barre d'objets, approche-toi du rig et clique. Une barre de vie apparaît au-dessus de lui après le premier coup, parce que par défaut un Humanoid n'affiche sa barre que lorsque sa Health est inférieure à sa MaxHealth. Un Humanoid commence avec 100 de vie, donc le cinquième coup le met K.-O.
  3. Clique aussi vite que tu peux. Seul un coup toutes les 0,6 seconde fait quelque chose.
  4. Recule d'environ 8 studs du rig, ou tourne-lui le dos, et frappe. Rien ne se passe, parce qu'aucune de ses parts n'est dans la boîte.
  5. Teste contre un vrai joueur. Choisis Server & Clients dans le menu déroulant du mode de test, règle 2 clients et appuie sur Play. Frappe l'autre joueur dans les 10 secondes qui suivent son apparition : rien ne se passe, à cause du ForceField d'apparition. Ensuite, chaque coup retire 20. Par défaut, les personnages des joueurs regagnent aussi 1 % de leur MaxHealth chaque seconde, donc leur vie remonte doucement entre les combats.
  6. Si ton jeu utilise les Teams, mets les deux joueurs de test dans la même équipe. Avec FRIENDLY_FIRE sur false, leurs coups ne se font rien.

Garde la fenêtre Output ouverte (menu Window, puis Output) pendant tout ce temps. Ces scripts n'affichent rien quand ils marchent, donc toute erreur rouge de SwordService ou de SwordClient est un vrai problème. Vois les problèmes courants.

En faire un système de combat

Combos

Garde un compteur de coups par joueur sur le serveur, à côté de lastSwing. Si le coup précédent était récent, ajoute 1 ; sinon repars de 1. Choisis ensuite les dégâts à partir du compte, par exemple plus de dégâts tous les trois coups, et vide le compteur sur PlayerRemoving de la même façon. Le client peut garder son propre compte pour choisir quelle animation jouer, parce que l'animation ne décide jamais d'un coup. La boîte et les vérifications restent exactement les mêmes.

Recul (knockback)

Après TakeDamage, SwordService peut repousser la cible avec ApplyImpulse sur la RootPart de la cible, dans la direction du rootPart.CFrame.LookVector de l'attaquant. La référence de Roblox dit que la poussée dépend de la masse de la cible, et qu'un Script serveur peut l'appeler sur une part que possède le serveur ou sur une part qu'un client possède automatiquement. L'appareil de chaque joueur simule son propre personnage, donc teste le recul sur des joueurs avec Server & Clients, pas seulement sur un rig.

Attribuer les éliminations pour un leaderboard

Juste avant target:TakeDamage(DAMAGE), enregistre qui a frappé en dernier avec target:SetAttribute("LastHitBy", player.UserId). Dans un Script serveur, connecte l'événement Died du Humanoid de chaque personnage, lis cet attribut, trouve l'attaquant avec Players:GetPlayerByUserId et ajoute 1 à une IntValue Kills dans son leaderstats. Crée-la à côté de Coins et Wins comme à l'étape 1 du guide du leaderboard, et change-la sur le serveur comme à l'étape 2.

Parade

Ajoute un deuxième RemoteEvent que le client déclenche quand le bouton de parade est enfoncé puis relâché, et fais régler par le serveur un attribut Blocking sur le personnage de ce joueur, avec sa propre limite de fréquence. Dans SwordService, baisse ou annule les dégâts quand le personnage de la cible a Blocking réglé. Un tricheur choisit quand même quand il pare, donc garde la parade courte ou donne-lui un cooldown.

Vendre l'épée ou la distribuer à chaque manche

StarterPack donne l'épée à chaque joueur à chaque apparition. Pour la vendre à la place, mets-la dans le dossier ShopItems du guide de l'interface de boutique. Le catalogue de ce guide vend déjà un Tool nommé ClassicSword, donc soit tu nommes ce Tool ClassicSword et tu règles SWORD_NAME en conséquence, soit tu changes l'entrée du catalogue. Pour ne la distribuer que pendant une manche, utilise le script GiveRoundTool du guide du système de manches : garde la Sword dans ServerStorage au lieu de StarterPack, et remplace "RoundTool" dans ce script par "Sword".

Des ennemis à combattre, et une arme à distance

Pour un PNJ qui poursuit les joueurs, suis le guide du pathfinding de PNJ. L'épée le blesse comme n'importe quel autre Humanoid. Pour une arme qui touche à distance avec les mêmes règles côté serveur, vois le guide du pistolet (en anglais).

Problèmes courants

Ouvre la fenêtre Output (menu Window, puis Output) avant d'appuyer sur Play. La plupart des problèmes d'épée y affichent une erreur ou viennent d'un nom qui ne correspond pas.

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

SwordClient attend le remote que crée SwordService, donc SwordService ne tourne pas. Vérifie que c'est un Script, pas un LocalScript, directement dans ServerScriptService, qu'il n'est pas désactivé, et qu'Output n'affiche aucune erreur venant de lui.

Je frappe mais rien ne prend de dégâts

Vérifie dans l'ordre : SwordClient est un LocalScript, pas un Script, directement dans le Tool Sword ; le Tool s'appelle exactement Sword, ou ce qu'indique SWORD_NAME ; la cible est à moins de 6 studs devant toi ; la cible est apparue il y a plus de 10 secondes, donc son ForceField d'apparition a disparu ; et, si tu utilises les Teams, que vous n'êtes pas dans la même équipe alors que FRIENDLY_FIRE est sur false.

L'épée touche les joueurs mais jamais mon PNJ

Les requêtes spatiales comme GetPartBoundsInBox ne renvoient jamais une part dont CanQuery est désactivé (CanQuery n'a d'effet que si CanCollide est désactivé aussi). Réactive CanQuery sur les parties du corps du PNJ, et vérifie que son Humanoid est un enfant direct du modèle du PNJ.

Mon personnage reste bloqué quand j'équipe l'épée

Une part de l'épée est ancrée. Sélectionne chaque part du Tool et décoche Anchored.

Certains coups touchent et d'autres ratent à la même distance

Avec la version à élan, une cible qui sort de la boîte pendant WINDUP_SECONDS est manquée, et le test de mur ignore quiconque se trouve derrière un mur ou un autre joueur. Réduis l'élan, ou élargis HIT_WIDTH, si les coups ratés semblent injustes pendant les tests.

Le personnage tient l'épée par la lame

Il y a plus d'une part nommée Handle, donc Roblox a choisi la mauvaise. Garde exactement une Handle, la poignée, et renomme les autres. Ajuste ensuite les propriétés de prise du Tool si l'angle est encore mauvais.

La lame reste en arrière ou tombe quand j'équipe l'épée

La lame n'est pas soudée à la Handle. Ajoute une WeldConstraint avec Part0 réglé sur Handle et Part1 réglé sur la lame.

Les dégâts s'affichent sur mon écran mais la vie de l'autre joueur ne change pas

Les dégâts sont infligés depuis un LocalScript, qui ne change que ta propre copie du jeu. N'inflige les dégâts que dans SwordService, comme à l'étape 2.

Le faire avec RoCode

Si tu préfères ne pas brancher tout ça à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA de code indépendant, qui n'est pas fait par Roblox : tu décris la fonctionnalité dans son chat web, et son plugin Roblox Studio crée le Tool, les parts et les scripts dans ton Explorer, donc tu ne copies pas de code depuis une fenêtre de chat.

Tu écris

Fais une épée : un Tool nommé Sword dans StarterPack avec une Handle et une lame soudée dessus, un LocalScript qui déclenche un RemoteEvent sur Activated, et un Script serveur qui vérifie un cooldown de 0,6 seconde et inflige 20 de dégâts aux Humanoids dans une boîte devant le joueur.

RoCode fait
  • Crée le Tool et ses parts avec Create Instance et règle leurs propriétés avec Set Property
  • Écrit SwordService et SwordClient avec Create Script, et peut d'abord chercher des scripts de combat existants avec Search Scripts
  • A pour consigne de vérifier la compilation de chaque script qu'il écrit avec Check Script, qui compile le code dans Studio sans le lancer (il ne vérifie pas les types)
  • Place un point d'annulation avant et après chaque lot de changements, donc Ctrl+Z revient en arrière un lot à la fois

RoCode ne peut pas créer l'animation du coup ni en téléverser une : crée-la dans l'Animation Editor et colle son ID. Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.11 ou plus récent il peut contrôler un personnage de test, mais il ne clique pas dans la vue 3D pour frapper, donc c'est toi qui testes les coups. Créer un jeu Roblox entier avec RoCode, système par système montre où se place une arme. Comment RoCode se connecte à Studio.

Questions fréquentes

Pourquoi mon épée touche le même joueur plusieurs fois en un seul coup ?

Parce qu'elle inflige les dégâts depuis Touched. La page de Roblox sur le debounce note que Touched se déclenche plusieurs fois de suite très vite pour un seul contact, et chaque part de la cible peut toucher la lame. Ce guide trouve les cibles avec une requête de boîte par coup et garde une liste, donc chaque Humanoid perd de la vie une fois par coup.

Les dégâts de l'épée vont-ils dans un LocalScript ou un Script ?

Dans un Script sur le serveur. Des dégâts infligés depuis un LocalScript ne changent que la copie du jeu de ce joueur, et tout ce qui est sur l'appareil du joueur peut être modifié par un tricheur. Le LocalScript doit seulement entendre le clic, jouer l'animation et déclencher le RemoteEvent.

Comment ajouter une animation de coup à mon épée ?

Crée-la dans l'Animation Editor, règle sa priorité sur Action, publie-la sur Roblox, et mets son asset ID dans SWING_ANIMATION_ID sous la forme rbxassetid:// suivi du nombre. SwordClient la joue avec l'Animator du personnage. Les animations que l'appareil d'un joueur lance sur le personnage de ce joueur sont montrées à tout le monde.

Pourquoi l'animation de mon épée ne se joue pas ?

Vérifie trois choses. La priorité : Action passe au-dessus de Movement, Idle et Core, donc un coup en Action se joue par-dessus la marche et l'attente, alors qu'une priorité plus basse peut perdre contre elles. Le propriétaire : si le jeu appartient à un groupe, publie l'animation avec ce groupe sélectionné comme Creator. L'ID : SWING_ANIMATION_ID doit être le texte rbxassetid:// complet avec le nombre de ton animation, pas une chaîne vide.

Quelle est la meilleure hitbox pour une épée Roblox ?

Pour la plupart des jeux, une requête de boîte sur le serveur une fois par coup, comme dans ce guide : un seul appel à GetPartBoundsInBox, rien qu'un client puisse falsifier, et trois nombres à régler. N'utilise GetPartsInPart avec une part en forme, ou des raycasts le long de la lame, que si la portée d'une arme est loin d'une boîte. Les quatre méthodes comparées.

Comment empêcher mon épée de toucher à travers les murs ?

Avant d'infliger les dégâts, lance un rayon de la part racine de l'attaquant à la part racine de la cible, en ignorant le personnage de l'attaquant, et ne compte le coup que si la première chose que rencontre le rayon appartient à la cible. La version 2 de SwordService le fait pour chaque cible.

Pourquoi le coup porte avant que l'animation atteigne la cible ?

Le serveur vérifie la hitbox à l'instant où le clic arrive. Attends d'abord un court élan, par exemple 0,15 seconde avec task.delay, puis vérifie que l'attaquant est toujours en vie et tient l'épée, et construis la boîte, comme le fait la version 2.

Les exploiteurs peuvent-ils encore tricher avec cette épée ?

Ils ne peuvent pas choisir qui est touché, combien de dégâts fait un coup ni à quelle fréquence ils frappent, parce que le serveur décide des trois ; le maximum qu'ils gagnent est la marge réseau de 0,1 seconde sur le cooldown. Ils peuvent toujours déplacer leur propre personnage, par exemple juste à côté de quelqu'un, parce que chaque appareil contrôle les déplacements de son propre personnage. Une vérification des déplacements côté serveur est la couche suivante.

Comment faire un système de combat avec des combos ?

Garde un compteur de coups par joueur sur le serveur, remets-le à zéro après une courte pause, et choisis les dégâts et l'animation à partir du compte. Le test du coup reste le même. Aller plus loin couvre aussi le recul, l'attribution des éliminations et la parade.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 12 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.