Pe scurt
Pune în StarterPack un Tool numit Sword, cu un part numit Handle. Un LocalScript din Tool ascultă Tool.Activated, redă animația de lovitură și apelează un RemoteEvent fără argumente. Un Script din ServerScriptService verifică cooldown-ul și faptul că jucătorul e viu și ține sabia, găsește fiecare Humanoid din cutia din fața lui prin workspace:GetPartBoundsInBox și apelează Humanoid:TakeDamage o singură dată per țintă.
- Nu aplica damage din evenimentul
Touchedal lamei: dispozitivul jucătorului își controlează personajul și poate declanșa Touched de oriunde, iar sabia e dată exact ca exemplu pe pagina Roblox despre network ownership. - Clientul nu trimite nici ținta, nici damage-ul. Cooldown-ul, hitbox-ul și mărimea damage-ului sunt ale serverului.
TakeDamagenu face nimic cât timp ținta are un ForceField, de exemplu în primele 10 secunde după spawn pe un SpawnLocation.- Loviturile trec prin pereți sau vin înainte ca lovitura să ajungă vizual la țintă? Ia versiunea scriptului de server cu avânt și verificare de pereți.
Pe această pagină
Cum e construită o sabie funcțională
O sabie care funcționează într-un joc adevărat e împărțită între dispozitivul jucătorului și server. Pagina Roblox despre unelte spune că inputul pentru unelte trebuie să stea într-un LocalScript, pentru că doar dispozitivul jucătorului știe când are loc inputul, și că majoritatea uneltelor au nevoie de un LocalScript, un Script de server și un RemoteEvent între ele. Acest ghid folosește exact această împărțire. O lovitură arată așa:
- Jucătorul dă clic, atinge ecranul sau apasă trigger-ul gamepadului cu Sword echipată. În LocalScript se declanșează
Tool.Activated. - LocalScript-ul redă animația de lovitură, dacă există, și apelează RemoteEvent-ul
SwordSwing. Altceva nu trimite. - Script-ul de server verifică cooldown-ul, faptul că jucătorul e viu și faptul că are Sword în mână.
- Serverul construiește propriul hitbox în fața personajului jucătorului și găsește fiecare Humanoid din el.
- Fiecare dintre acești Humanoid pierde o singură dată viață prin
TakeDamage.
| Element | Unde se află | Ce face |
|---|---|---|
Tool Sword | StarterPack | Ce ține jucătorul. Roblox copiază tot din StarterPack în Backpack-ul jucătorului la fiecare spawn al personajului său. |
Part Handle | În Tool | Part-ul de care se ține personajul. Lama e sudată de el. |
LocalScript SwordClient | În Tool | Aude clicul, redă animația de lovitură și apelează remote-ul. |
RemoteEvent SwordSwing | ReplicatedStorage (îl creează SwordService) | Duce „am lovit” de pe dispozitivul jucătorului la server, fără argumente. |
Script SwordService | ServerScriptService | Verifică fiecare lovitură, găsește cine stă în fața jucătorului și aplică damage-ul. Singurul loc unde poate avea loc o lovitură. |
ServerScriptService
SwordService Script new
StarterPack
Sword Tool new
Handle Part new
Blade Part new
WeldConstraint WeldConstraint new
SwordClient LocalScript new
Pasul 1: construiește Tool-ul sabiei
- În Explorer treci cu mouse-ul peste Workspace, apasă butonul + și inserează un Tool. Redenumește-l în
Sword. Scriptul de server caută exact acest nume. Construiești sabia în Workspace, cum recomandă pagina Roblox despre unelte, pentru că acolo i se văd parts-urile și le poți muta și redimensiona. Ultimul pas o mută în StarterPack. - Inserează în Tool un Part și numește-l
Handle. Este mânerul de care personajul ține sabia. Trebuie să fie copil direct al Tool-ului și singurul part cu acest nume: cu două Handle, Roblox alege unul la întâmplare, iar personajul poate ține sabia de lamă. - Inserează în Tool un al doilea Part, numește-l
Blade, dă-i formă și așază-l astfel încât să iasă din partea de sus a lui Handle. - Inserează în Blade un WeldConstraint. În fereastra Properties setează-i
Part0la Handle, iarPart1la Blade, ca sabia să rămână întreagă cât timp jucătorul o poartă. - Selectează ambele parts și asigură-te că Anchored e oprit. Un part ancorat într-o unealtă îl țintuiește pe loc pe personaj când o echipează. Oprește la amândouă și CanCollide, ca lama să nu se lovească de jucători și pereți la lovitură.
- Selectează Tool-ul și debifează CanBeDropped. Când e bifat, apăsarea Backspace aruncă sabia în Workspace.
- Trage Sword gata din Workspace în StarterPack. Un Tool lăsat în Workspace e un obiect de ridicat, pe care îl ia un singur jucător, nu o sabie care stă de la început în Backpack-ul fiecăruia.
Merge și o sabie dintr-un singur MeshPart: numește acel MeshPart Handle și sari peste Weld. Dacă la test personajul ține sabia într-un unghi ciudat, selectează Tool-ul și ajustează-i proprietățile de prindere (GripPos, GripForward, GripRight și GripUp) în fereastra Properties.
Pasul 2: adaugă scriptul de server
Treci cu mouse-ul peste ServerScriptService, inserează un Script numit SwordService și lipește în el codul de mai jos. Acesta e singurul loc unde poate avea loc o lovitură de sabie. Setările de la început sunt liniile pe care trebuie să le schimbi.
-- Script în ServerScriptService, numit SwordService.
-- Singurul loc unde poate avea loc o lovitură de sabie: verifică lovitura, găsește țintele din fața
-- atacatorului cu propriul hitbox și aplică damage-ul.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Setări
local SWORD_NAME = "Sword" -- numele Tool-ului din StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- păstrați aceeași valoare în SwordClient
local HIT_RANGE = 6 -- studs în fața atacatorului
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: jucătorii din aceeași echipă nu se pot răni între ei
-- Loviturile trimise exact la COOLDOWN_SECONDS pot ajunge, după întârzierea rețelei,
-- puțin mai apropiate, așa că serverul dă această rezervă și nu respinge o lovitură reală
local NETWORK_SLACK = 0.1
-- Remote-ul pe care îl apelează LocalScript-ul sabiei. Nu poartă argumente: cine e lovit
-- decide serverul, așa că clientul nu are ce falsifica.
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
-- Jucătorii neutri (fără echipă) se pot lovi mereu între ei
return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end
local function onSwing(player: Player)
-- 1. O lovitură pe cooldown, oricât de des ar fi apelat remote-ul
local now = os.clock()
local last = lastSwing[player]
if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
return
end
-- 2. Atacatorul trebuie să fie viu și să țină sabia
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. Hitbox-ul propriu al serverului: o cutie în fața part-ului rădăcină al atacatorului
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. Fiecare Humanoid din cutie primește damage o singură dată, chiar dacă are mai multe parts înăuntru
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) -- nu face nimic cât timp ținta are un ForceField
end
end
end
end
swingEvent.OnServerEvent:Connect(onSwing)
Players.PlayerRemoving:Connect(function(player: Player)
lastSwing[player] = nil
end)
SwordService își creează singur RemoteEvent-ul SwordSwing la pornirea jocului, așa că nu trebuie să inserezi nimic de mână în ReplicatedStorage. Dacă ai creat deja un RemoteEvent cu acest nume, șterge-l: LocalScript-ul l-ar putea găsi pe al tău, iar pe acela nu-l ascultă nimeni pe server.
| Setare | Valoarea de aici | Ce schimbă |
|---|---|---|
SWORD_NAME | "Sword" | Numele Tool-ului pe care serverul îl așteaptă în mâna jucătorului. Schimbă-l dacă Tool-ul tău se numește altfel. |
DAMAGE | 20 | Câtă viață ia fiecare lovitură. Un Humanoid pornește cu 100 de viață, așa că cinci lovituri doboară rig-ul de test. Personajele jucătorilor își refac implicit 1% din MaxHealth în fiecare secundă, așa că un jucător lovit cu viteza maximă supraviețuiește loviturii a cincea și e nevoie de a șasea. |
COOLDOWN_SECONDS | 0.6 | Timpul dintre lovituri. Setează aceeași valoare în SwordClient. |
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT | 6, 5, 6 | Hitbox-ul în studs: cât de departe ajunge în fața jucătorului, cât de lat și cât de înalt e. |
FRIENDLY_FIRE | false | Cu false, jucătorii din aceeași echipă nu se pot răni între ei. Jucătorii fără echipă se pot lovi mereu între ei, iar NPC-urile pot fi lovite mereu. |
NETWORK_SLACK | 0.1 | Cu cât mai devreme de cooldown serverul încă acceptă o lovitură. Două clicuri la 0.6 secunde unul de altul pot ajunge, după întârzierea rețelei, puțin mai apropiate, iar fără această rezervă serverul ar respinge o lovitură reală pe care jucătorul a văzut-o deja. |
Pasul 3: adaugă LocalScript-ul în Tool
Inserează în Tool-ul Sword un LocalScript, numește-l SwordClient și lipește în el acest cod:
-- LocalScript în Tool-ul Sword, numit SwordClient.
-- Tool.Activated se declanșează pe dispozitivul jucătorului, așa că acest script ascultă clicul,
-- atingerea sau trigger-ul, redă animația de lovitură și îi cere serverului să facă lovitura.
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 -- aceeași valoare ca în SwordService
local SWING_ANIMATION_ID = "" -- opțional: "rbxassetid://" urmat de id-ul animației tale
local player = Players.LocalPlayer
local lastSwing = 0
local swingTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil
-- Încărcăm animația o singură dată per personaj. Animațiile pornite pe propriul tău
-- personaj de pe dispozitivul tău sunt arătate tuturor jucătorilor.
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 -- serverul verifică și el asta; verificarea de aici scutește cereri inutile
end
lastSwing = now
if swingTrack then
swingTrack:Play()
end
swingEvent:FireServer()
end)
Deocamdată lasă SWING_ANIMATION_ID gol. Sabia funcționează și fără animație, pentru că lovitura o decide oricum serverul. Cum îl completezi e arătat în secțiunea Adaugă o animație de lovitură.
Activated se declanșează la clicul mouse-ului, la atingerea pe telefon și la trigger-ul de pe gamepad, așa că același script funcționează pe orice dispozitiv. Roblox copiază Tool-ul și LocalScript-ul din el în Backpack-ul fiecărui jucător la spawn-ul personajului său, așa că fiecare jucător are propria copie care rulează.
LocalScript-ul ține un cooldown propriu doar ca să nu trimită cereri pe care serverul le-ar ignora oricum. Nu e o verificare de securitate: un trișor îl poate șterge, schimba sau poate apela SwordSwing din propriul cod. Ghidul RemoteEvent explică de ce fiecare remote trebuie verificat pe server, iar Script vs LocalScript vs ModuleScript (în engleză) arată ce poate și ce nu poate schimba un LocalScript.
Cum decide serverul cine a fost lovit
Când sosește SwordSwing, SwordService nu întreabă nimic clientul. Construiește o cutie în fața personajului atacatorului, acolo unde îl vede serverul, și întreabă motorul ce parts se află înăuntru, prin workspace:GetPartBoundsInBox. Această metodă înlocuiește mai vechiul FindPartsInRegion3, pe care Roblox îl marchează ca învechit.
Centrul cutiei se află la 3 studs în fața part-ului rădăcină al atacatorului. Este decalajul CFrame.new(0, 0, -HIT_RANGE / 2): un CFrame privește de-a lungul axei Z negative, acesta e LookVector-ul lui. Așa că cutia se întinde de la mijlocul personajului cu 6 studs înainte, are 5 studs lățime și 6 înălțime. Interogarea compară cutia de încadrare (bounding box) a fiecărui part, o aproximare rapidă a volumului său în formă de cutie, așa că parts-urile rotunde și meshurile contează puțin mai mari decât arată. Pentru o sabie, această mică rezervă e utilă.
| Pas | Cod | De ce |
|---|---|---|
| Sari peste atacator | OverlapParams cu Exclude și personajul atacatorului | Brațele, picioarele și sabia atacatorului sunt și ele în cutie. |
| Găsește personajul | part:FindFirstAncestorOfClass("Model") | Un part din cutie poate fi un membru, o pălărie sau o unealtă din mână. FindFirstAncestorOfClass compară numele exact al clasei, așa că trece pe lângă pălărie (clasa Accessory) și pe lângă unealta din mână (clasa Tool, deși Tool e un fel de Model) și se oprește la modelul personajului. |
| Găsește Humanoid-ul | model:FindFirstChildOfClass("Humanoid") | Poate fi lovit orice are un Humanoid: jucători, NPC-uri și manechine de test. Pereții și podelele sunt sărite. |
| O dată per Humanoid | tabelul alreadyHit | În cutie ajung de obicei mai multe parts ale aceluiași personaj. Fără tabel, fiecare dintre ele ar aplica damage din nou. |
| Doar ținte vii | target.Health > 0 | Un personaj deja doborât nu e lovit din nou. |
| Echipe | isTeammate | Cu FRIENDLY_FIRE egal cu false, jucătorii din aceeași echipă sunt săriți. Un jucător a cărui proprietate Neutral e true nu are echipă. |
| Damage | target:TakeDamage(DAMAGE) | Scade Health, dacă ținta nu e protejată de un ForceField. |
Tabelul alreadyHit se creează din nou la fiecare lovitură, așa că același jucător poate fi lovit iar cu următoarea lovitură, când trece cooldown-ul. Aceasta e regula „o dată per țintă per lovitură”, cu care săbiile pe Touched au mereu probleme.
Scriptul folosește TakeDamage, nu atribuirea lui Health. Referința Roblox spune că TakeDamage nu atinge un Humanoid cât timp îl protejează un ForceField, iar atribuirea directă a lui Health ignoră ForceField-ul. Un jucător care face spawn pe un SpawnLocation primește implicit un ForceField pentru 10 secunde (Duration al SpawnLocation), așa că nou-veniții nu pot fi loviți în momentul apariției.
Patru moduri de a face hitbox-ul unei săbii: comparație
Tutorialele de săbii diferă mai ales într-un singur punct: cum afli în ce a nimerit lama. Există patru răspunsuri răspândite. Se deosebesc prin cât de exact urmăresc lama, câtă muncă îi cer serverului și dacă un trișor poate falsifica rezultatul.
| Metodă | Cum funcționează | Cine decide | Precizie | Pentru ce e cea mai bună |
|---|---|---|---|---|
Touched pe lamă | Damage de fiecare dată când part-ul lamei atinge un personaj | Dispozitivul atacatorului, care își deține personajul și sabia | Urmărește lama, dar se declanșează de mai multe ori per atingere | Pentru nimic într-un joc cu alți jucători: dispozitivul atacatorului îl poate declanșa de oriunde |
| Cutie în fața jucătorului (acest ghid) | O singură interogare GetPartBoundsInBox pe server per lovitură | Serverul | O cutie fixă, nu traiectoria lamei. Meshurile contează după cutiile de încadrare, deci puțin generos | Majoritatea jocurilor: simplu, ieftin și nimic de falsificat |
GetPartsInPart pe un part-hitbox | Interogare pe server cu un part în forma arcului lamei, în timpul loviturii | Serverul | Forme exacte: documentația Roblox spune că face o verificare geometrică completă și propune interogări pe cutie sau sferă când ajunge o precizie mai mică, pentru că sunt mai ieftine | Arme mari cu formă neobișnuită, de exemplu arcul unei coase |
| Raycasturi de-a lungul lamei | În fiecare cadru al loviturii, raze scurte pornesc din puncte de pe lamă spre unde erau ele în cadrul trecut | Partea care le lansează. Pe server îți trebuie o reprezentare pe server a poziției lamei | Urmărește îndeaproape animația | Jocuri unde contează traiectoria exactă a loviturii. Așa funcționează modulele de hitbox ale comunității |
Cutia este prima alegere corectă. E o singură interogare per lovitură, nu depinde niciodată de o animație pe care un trișor ar putea-o schimba și se reglează ușor cu trei numere. Treci la un part cu forma potrivită sau la raze de-a lungul lamei când jucătorii se plâng că loviturile se simt greșit la o armă a cărei rază e departe de o cutie, și păstrează aceeași regulă: interogarea o rulează și damage-ul îl aplică serverul.
Presetări de săbii: de la pumnal la spada cu două mâini
Același SwordService face arme foarte diferite cu cinci setări. Tabelul e un punct de plecare, calculat pentru un manechin din Rig Generator cu 100 Health. „Timpul până la knockout” se socotește de la prima lovitură, când fiecare lovitură nimerește imediat ce permite cooldown-ul.
| Armă | DAMAGE | COOLDOWN_SECONDS | HIT_RANGE | HIT_WIDTH | Lovituri (timp) | Damage pe secundă |
|---|---|---|---|---|---|---|
| Pumnal | 12 | 0.35 | 4 | 4 | 9 (2.8 s) | în jur de 34 |
| Sabie (acest ghid) | 20 | 0.6 | 6 | 5 | 5 (2.4 s) | în jur de 33 |
| Spadă cu două mâini | 35 | 1.1 | 7 | 7 | 3 (2.2 s) | în jur de 32 |
| Suliță | 18 | 0.8 | 9 | 3 | 6 (4 s) | în jur de 23 |
- Jucătorii se vindecă, manechinele nu. Personajele jucătorilor își refac implicit 1% din MaxHealth în fiecare secundă. La exact 100 de damage din 5 lovituri, un jucător lovit cu viteza maximă supraviețuiește loviturii a cincea și e nevoie de a șasea. Lasă o rezervă, de exemplu 21 de damage în loc de 20, dacă numărul exact de lovituri contează.
- Scalează NETWORK_SLACK odată cu cooldown-ul. Cele 0.1 secunde din ghid sunt o șesime din 0.6. Dacă lași 0.1 la un pumnal cu cooldown de 0.35 secunde, un trișor ar putea lovi la fiecare 0.25 secunde, cu 40% mai repede. Ia aproximativ o șesime din
COOLDOWN_SECONDS: 0.06 pentru pumnal. - Ține SwordClient în acord. Setează acolo același
COOLDOWN_SECONDS, altfel clientul trimite lovituri pe care serverul le ignoră.
Versiunea 2: avânt și nicio lovitură prin pereți
Când sabia de bază merge, apar două plângeri. Lovitura vine în aceeași clipă în care jucătorul a dat clic, înainte ca animația să ajungă la țintă, și lovitura îl poate atinge pe cineva aflat de cealaltă parte a unui perete subțire, pentru că cutia nu ține cont de perete. Această versiune a SwordService le rezolvă pe amândouă. Înlocuiește scriptul de la pasul 2: același nume, același remote, aceleași setări, așa că SwordClient nu trebuie schimbat.
-- Script în ServerScriptService, numit SwordService (versiunea cu avânt și verificare de pereți).
-- Înlocuiește scriptul de la pasul 2: aceleași setări și același remote, plus două reguli. Lovitura vine
-- la WINDUP_SECONDS după clic, când lovitura ajunge la țintă, și nu atinge pe nimeni
-- prin perete.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Setări
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- păstrați aceeași valoare în SwordClient
local WINDUP_SECONDS = 0.15 -- timpul de la clic la lovitură; potriviți-l cu animația voastră de lovitură
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
-- Returnează personajul și part-ul rădăcină al atacatorului cât timp e viu și ține sabia
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 când între atacator și țintă nu e nimic în afară de ținta însăși
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)
-- Verificăm din nou după avânt: atacatorul putea muri sau putea pune sabia deoparte
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)
Mai întâi șterge SwordService de la pasul 2, altfel ambele scripturi vor crea câte un remote SwordSwing. Setează WINDUP_SECONDS la momentul din animația ta de lovitură în care lama trece prin fața personajului; pentru o lovitură rapidă merge 0.15.
- Avântul. Cooldown-ul și verificările „viu și ține sabia” rulează când sosește clicul, apoi
task.delayporneștestrikedupăWINDUP_SECONDS.strikeverifică atacatorul încă o dată, pentru că între timp putea muri sau putea pune sabia deoparte, și abia apoi construiește cutia. O țintă care a ieșit din raza de acțiune în timpul avântului nu e lovită, și exact asta așteaptă jucătorii când văd lovitura. - Verificarea de pereți. Pentru fiecare țintă din cutie,
hasClearLinelansează o rază de la part-ul rădăcină al atacatorului la part-ul rădăcină al țintei, sărind peste personajul atacatorului. Dacă primul lucru întâlnit aparține țintei sau nu întâlnește nimic, lovitura contează. Un perete, o ușă sau alt jucător între ei o blochează. - Cât costă. O rază în plus per țintă per lovitură, ceea ce e puțin față de interogarea cutiei în sine.
Avântul face sabia și mai corectă împotriva trișorilor care lovesc în aceeași clipă în care se teleportează lângă cineva: serverul caută țintele o clipă mai târziu, acolo unde vede personajele în acel moment. Teleportul în sine nu e oprit de asta; pentru asta îți trebuie verificarea mișcării, descrisă în secțiunea Ce poate și ce nu poate un exploiter.
Adaugă o animație de lovitură (opțional)
SwordClient redă deja animația imediat ce îi dai un ID. Animația o faci o singură dată, în Animation Editor din Studio:
- Inserează un rig pentru animație. În fila Avatar sau Home apasă Character ca să deschizi Rig Generator și alege un rig care se potrivește cu avatarele jocului tău, de exemplu R15 și apoi Block Avatar.
- În fila Avatar apasă Clip Editor ca să deschizi Animation Editor, selectează rig-ul și pune pozițiile pentru o lovitură scurtă cu mâna dreaptă.
- Setează prioritatea Action: apasă butonul … din controalele de redare ale editorului, treci cu mouse-ul peste Set Animation Priority și alege Action. Action stă deasupra lui Movement, Idle și Core, așa că lovitura se redă peste animațiile de mers și de stat, în loc să piardă în fața lor.
- În același meniu … alege Publish to Roblox. Dacă jocul tău aparține unui grup, alege acel grup în câmpul Creator înainte de trimitere.
- Copiază asset ID-ul animației din Toolbox și în SwordClient setează
SWING_ANIMATION_IDla"rbxassetid://"urmat de acel număr.
SwordClient încarcă lovitura prin Animator-ul personajului, nu prin mai vechiul Humanoid:LoadAnimation, pe care Roblox îl marchează ca învechit. Referința Roblox pentru Animator spune că animațiile pe care dispozitivul unui jucător le pornește pe propriul personaj al acelui jucător se replică pe server și la toți ceilalți jucători, așa că un LocalScript poate reda lovitura și o vor vedea toți. Tot acolo se spune că Animator-ul trebuie creat pe server, așa că nu-l crea niciodată într-un LocalScript. La personajele jucătorilor stă de obicei în Humanoid, și exact acolo îl caută exemplul propriu de animație al Roblox.
Animația e doar pentru aspect. Loviturile nu depind de ea, așa că o animație lentă, lipsă sau schimbată nu schimbă niciodată cine e lovit.
Cum redai o animație la apăsarea unei taste, în buclă sau pe un NPC, citește în ghidul de script de animație.
Unde greșesc tutorialele vechi de săbii
Dacă compari acest ghid cu un video sau o postare pe forum, iată diferențele importante și motivul pentru care fiecare tehnică creează o problemă.
| Tutorialul | Problema | Acest ghid |
|---|---|---|
Aplică damage în evenimentul Touched al lamei | Dispozitivul atacatorului poate declanșa Touched pe sabia lui de oriunde (pagina Roblox despre network ownership), iar Touched se declanșează de mai multe ori la rând pentru o singură atingere (pagina Roblox despre debounce). | Serverul găsește țintele cu propria cutie, o dată per Humanoid per lovitură. |
| Scade Health într-un LocalScript | O schimbare pe care un LocalScript o face personajului altcuiva rămâne pe acel singur dispozitiv. | Tot damage-ul se aplică în SwordService. |
Folosește wait(0.5) pentru cooldown | Roblox marchează wait() global ca învechit, în locul lui se folosește task.wait(), iar un cooldown care există doar pe client nu oprește pe nimeni. | Compară timpul os.clock() pe server. Nimic nu așteaptă. |
Redă lovitura prin Humanoid:LoadAnimation | Învechit, în locul lui se folosește Animator:LoadAnimation. | Încarcă lovitura prin Animator. |
Caută țintele prin Region3 și FindPartsInRegion3 | Învechit. Roblox recomandă în proiectele noi GetPartBoundsInBox cu OverlapParams. | Folosește GetPartBoundsInBox. |
Pune un Script de server în Tool, care ascultă Activated | Sabia fiecărui jucător rulează propria copie a codului de server, iar asemenea scripturi aplică adesea damage în Touched (primul rând). Cu setările implicite, un Script rulează doar în Workspace sau ServerScriptService, așa că un Script dintr-un Tool nu pornește până când sabia nu e echipată prima dată. Pagina Roblox despre unelte descrie majoritatea uneltelor ca un LocalScript pentru input, un Script de server pentru efect și un RemoteEvent între ele. | Un singur SwordService în ServerScriptService deservește toate săbiile din joc. |
Ce poate și ce nu poate un exploiter
Pleacă de la ideea că un trișor controlează tot pe dispozitivul lui. Îți poate citi și schimba LocalScript-urile, iar ghidul Roblox despre securitate spune că poate apela RemoteEvent-uri cu orice frecvență și cu argumente arbitrare. Iată ce înseamnă asta pentru această sabie.
| Trișorul încearcă | Rezultat | De ce |
|---|---|---|
Să apeleze SwordSwing cât de repede poate codul lui sau să folosească un autoclicker | Contează cel mult o lovitură la fiecare 0.5 secunde | Cooldown-ul de pe server este 0.6 secunde minus 0.1 secunde de rezervă de rețea. Această rezervă e tot ce câștigă trișorul. |
| Să trimită cu remote-ul o țintă, un număr de damage sau o poziție | Ignorat | onSwing citește doar jucătorul pe care îl pune Roblox însuși. Orice altceva trimis cu remote-ul nu e citit niciodată. |
| Să schimbe SwordClient, de exemplu să-i scoată cooldown-ul | Nu afectează serverul | SwordService își ține setările în ServerScriptService, care nu e trimis niciodată jucătorilor. |
| Să lovească fiind mort sau fără sabie în mână | Ignorat | SwordService verifică faptul că Humanoid-ul lui e viu și că Tool-ul numit Sword e în personajul lui, unde Roblox mută unealta la echipare. |
| Să lovească pe cineva de la celălalt capăt al hărții | Nu se întâmplă nimic | Cutia se construiește în jurul personajului atacatorului, acolo unde îl vede serverul, și ajunge doar la 6 studs înainte. |
| Să se teleporteze lângă un jucător și apoi să lovească | Posibil | Fiecare dispozitiv controlează mișcarea propriului personaj, iar Roblox enumeră teleportarea în orice punct printre lucrurile pe care clientul le poate face cu personajul lui. O verificare a mișcării pe server o poate depista. |
| Să lovească printr-un perete subțire | Posibil în limitele cutiei de 6 studs | Interogarea cutiei de la pasul 2 nu caută pereți. Versiunea 2 adaugă verificarea de pereți. |
| Să redea orice animație sau niciuna | Nu afectează loviturile | Loviturile nu depind niciodată de animație. Roblox notează că trișorii pot reda animații arbitrare pe personajul lor. |
În două rânduri scrie „Posibil”, și e cinstit. Această sabie nu-l lasă pe trișor să aleagă pe cine lovește, cât de tare și cât de des. Nu-l poate împiedica să-și miște propriul personaj. Documentația Roblox despre securitate spune că clienții controlează mișcarea și fizica personajului lor și că verificările de mișcare trebuie reglate pentru fiecare joc. Pentru un joc competitiv, următorul strat este o verificare a mișcării pe server (ghidul de sprint construiește una, care avertizează despre speedhack-urile grosolane și teleporturile lungi) sau server authority de la Roblox, pe care documentația o descria ca beta când am verificat pe 13 octombrie 2026.
Pasul 4: testează
- Adaugă ceva de lovit. În fila Avatar sau Home apasă Character ca să deschizi Rig Generator, alege un rig (de exemplu R15, apoi Block Avatar), iar el se inserează în Workspace. Mută-l la câțiva studs de SpawnLocation-ul tău.
- Apasă Play, echipează Sword din hotbar, apropie-te de rig și dă clic. După prima lovitură, deasupra lui apare o bară de viață, pentru că implicit un Humanoid arată bara doar când Health e sub MaxHealth. Un Humanoid pornește cu 100 de viață, așa că a cincea lovitură îl doboară.
- Dă clic cât de repede poți. Face ceva doar o lovitură la fiecare 0.6 secunde.
- Îndepărtează-te de rig cu aproximativ 8 studs sau întoarce-i spatele și lovește. Nu se întâmplă nimic, pentru că niciunul dintre parts-urile lui nu e în cutie.
- Testează pe un jucător real. Alege Server & Clients din lista derulantă a modurilor de test, setează 2 clienți și apasă Play. Lovește celălalt jucător în primele 10 secunde după spawn-ul lui: nu se întâmplă nimic, din cauza ForceField-ului de la spawn. După aceea, fiecare lovitură ia 20. Implicit, personajele jucătorilor își mai și refac 1% din MaxHealth în fiecare secundă, așa că între lupte viața lor revine încet.
- Dacă jocul tău are Teams, pune ambii jucători de test în aceeași echipă. Cu
FRIENDLY_FIREegal cu false, loviturile lor nu își fac nimic unul altuia.
În tot acest timp ține fereastra Output deschisă (meniul Window, apoi Output). Când aceste scripturi funcționează, nu afișează nimic, așa că orice eroare roșie de la SwordService sau SwordClient e o problemă reală. Vezi Erori frecvente.
Cum extinzi sabia într-un sistem de luptă
Combo
Ține pe server un contor de lovituri per jucător, lângă lastSwing. Dacă lovitura de dinainte a fost recentă, adună 1; altfel începe din nou de la 1. Apoi alege damage-ul după contor, de exemplu mai mult damage la fiecare a treia lovitură, și golește contorul la PlayerRemoving în același fel. Clientul își poate ține propriul număr ca să aleagă ce animație redă, pentru că animația nu decide niciodată lovitura. Cutia și verificările rămân exact la fel.
Knockback
După TakeDamage, SwordService poate împinge ținta prin ApplyImpulse pe RootPart-ul țintei, în direcția rootPart.CFrame.LookVector a atacatorului. Referința Roblox spune că împingerea depinde de masa țintei și că un Script de server o poate apela pe un part deținut de server sau pe un part deținut automat de client. Dispozitivul fiecărui jucător își simulează propriul personaj, așa că testează knockback-ul pe jucători prin Server & Clients, nu doar pe un rig.
Ucideri pentru clasament
Chiar înainte de target:TakeDamage(DAMAGE) notează cine a lovit ultimul, prin target:SetAttribute("LastHitBy", player.UserId). Într-un Script de server conectează evenimentul Died al Humanoid-ului fiecărui personaj, citește acest atribut, găsește atacatorul prin Players:GetPlayerByUserId și adună 1 la IntValue-ul Kills din leaderstats-ul lui. Creează-l lângă Coins și Wins, ca în pasul 1 din ghidul de clasament, și schimbă-l pe server, ca în pasul 2.
Blocare
Adaugă un al doilea RemoteEvent, pe care clientul îl apelează când butonul de blocare e apăsat și eliberat, și lasă serverul să seteze atributul Blocking pe personajul acelui jucător, cu propria limită de frecvență. În SwordService redu sau sari peste damage când personajul țintei are Blocking setat. Trișorul tot alege singur când blochează, așa că fă blocarea scurtă sau dă-i un cooldown.
Vânzarea sabiei sau acordarea ei la fiecare rundă
StarterPack dă sabia fiecărui jucător la fiecare spawn. Ca s-o vinzi în schimb, pune-o în folderul ShopItems din ghidul de GUI de magazin. Catalogul acelui ghid vinde deja un Tool numit ClassicSword, așa că fie numești acest Tool ClassicSword și setezi același SWORD_NAME, fie schimbi intrarea din catalog. Ca s-o dai doar pe durata unei runde, ia scriptul GiveRoundTool din ghidul de sistem de runde: ține Sword în ServerStorage, nu în StarterPack, și înlocuiește "RoundTool" din acel script cu "Sword".
Inamici de luptă și arme la distanță
Pentru un NPC care urmărește jucătorii, urmează ghidul de pathfinding pentru NPC. Sabia îi face damage ca oricărui alt Humanoid. Despre armele care lovesc la distanță după aceleași reguli de server, citește în ghidul de arme.
Erori frecvente și soluții
Deschide fereastra Output (meniul Window, apoi Output) înainte să apeși Play. Majoritatea problemelor cu sabia fie afișează acolo o eroare, fie apar dintr-un nume care nu se potrivește.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SwordSwing")'
SwordClient așteaptă remote-ul pe care îl creează SwordService, deci SwordService nu rulează. Verifică faptul că e un Script, nu un LocalScript, că stă direct în ServerScriptService, nu e dezactivat și că în Output nu există o eroare de la el.
Lovesc, dar nimeni nu primește damage
Verifică în ordine: SwordClient e un LocalScript, nu un Script, și stă direct în Tool-ul Sword; Tool-ul se numește exact Sword sau cum scrie în SWORD_NAME; ținta e la cel mult 6 studs în fața ta; ținta a făcut spawn acum mai mult de 10 secunde, așa că ForceField-ul ei a dispărut; și, dacă folosești Teams, nu sunteți în aceeași echipă cu FRIENDLY_FIRE egal cu false.
Sabia lovește jucători, dar niciodată NPC-ul meu
Interogările spațiale precum GetPartBoundsInBox nu returnează niciodată un part cu CanQuery oprit (CanQuery contează doar când e oprit și CanCollide). Pornește la loc CanQuery pe părțile corpului NPC-ului și verifică faptul că Humanoid-ul lui e copil direct al modelului NPC.
Personajul meu se blochează când echipez sabia
Un part al sabiei e ancorat. Selectează toate parts-urile din Tool și debifează Anchored.
Unele lovituri nimeresc, iar altele ratează la aceeași distanță
În versiunea cu avânt, o țintă care a ieșit din cutie în WINDUP_SECONDS nu e lovită, iar verificarea de pereți sare peste oricine stă după un perete sau după alt jucător. Micșorează avântul sau mărește HIT_WIDTH dacă în playtesturi ratările par nedrepte.
Personajul ține sabia de lamă
Există mai mult de un part numit Handle, iar Roblox l-a ales pe cel greșit. Păstrează exact un Handle, mânerul, și redenumește-le pe celelalte. Apoi ajustează proprietățile de prindere ale Tool-ului, dacă unghiul e tot greșit.
Lama rămâne pe loc sau cade când echipez sabia
Lama nu e sudată de Handle. Adaugă un WeldConstraint cu Part0 egal cu Handle și Part1 egal cu lama.
Damage-ul se vede pe ecranul meu, dar viața celuilalt jucător nu se schimbă
Damage-ul se aplică dintr-un LocalScript, care schimbă doar copia ta a jocului. Aplică damage doar în SwordService, ca la pasul 2.
Fă-o cu RoCode
Dacă nu ai chef să construiești toate acestea de mână, RoCode le poate face în place-ul pe care îl ai deschis. Este un agent AI independent pentru scrierea de cod, nu de la Roblox: descrii funcția în chatul lui web, iar pluginul lui pentru Roblox Studio creează Tool-ul, parts-urile și scripturile în Explorer-ul tău, așa că nu trebuie să copiezi cod din fereastra de chat.
Fă o sabie: un Tool numit Sword în StarterPack, cu un Handle și o lamă sudată de el, un LocalScript care apelează un RemoteEvent la Activated și un Script de server care verifică un cooldown de 0.6 secunde și aplică 20 de damage tuturor Humanoid-urilor din cutia din fața jucătorului.
- Creează Tool-ul și parts-urile lui prin Create Instance și le setează proprietățile prin Set Property
- Scrie SwordService și SwordClient prin Create Script și poate căuta întâi scripturile de luptă existente prin Search Scripts
- Are instrucțiunea să verifice compilarea fiecărui script scris prin Check Script, care compilează codul în Studio fără să-l ruleze (tipurile nu le verifică)
- Pune un punct de undo înainte și după fiecare pachet de schimbări, așa că Ctrl+Z anulează câte un pachet
RoCode nu poate face animația de lovitură și nici s-o încarce: fă-o în Animation Editor și lipește-i ID-ul. Cu pluginul 3.9 sau mai nou RoCode poate porni un playtest scurt și poate citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test, dar nu dă clic în fereastra 3D ca să lovească, așa că loviturile le verifici tu. Pagina cum creezi un joc Roblox întreg cu RoCode, sistem cu sistem arată unde intră armele. Cum se conectează RoCode la Studio.
Întrebări frecvente
De ce sabia mea lovește un jucător de mai multe ori dintr-o singură lovitură?
Pentru că aplică damage din Touched. Pagina Roblox despre debounce notează că Touched se declanșează de mai multe ori la rând pentru o singură atingere, iar fiecare part al țintei poate atinge lama. Acest ghid găsește țintele cu o singură interogare de cutie per lovitură și ține o listă, așa că fiecare Humanoid pierde viață o singură dată per lovitură.
Damage-ul sabiei trebuie să fie în LocalScript sau în Script?
Într-un Script pe server. Damage-ul aplicat dintr-un LocalScript schimbă doar copia jocului a acelui jucător, iar tot ce se află pe dispozitivul jucătorului un trișor poate schimba. LocalScript-ul trebuie doar să audă clicul, să redea animația și să apeleze RemoteEvent-ul.
Cum îi adaug sabiei o animație de lovitură?
Fă-o în Animation Editor, setează prioritatea Action, publică în Roblox și scrie asset ID-ul ei în SWING_ANIMATION_ID ca rbxassetid:// urmat de număr. SwordClient o redă prin Animator-ul personajului. Animațiile pe care dispozitivul unui jucător le pornește pe propriul personaj al acelui jucător sunt arătate tuturor.
De ce nu se redă animația sabiei?
Verifică trei lucruri. Prioritatea: Action stă deasupra lui Movement, Idle și Core, așa că o lovitură cu Action se redă peste mers și stat, iar o prioritate mai mică poate pierde în fața lor. Proprietarul: dacă jocul aparține unui grup, publică animația alegând acel grup ca Creator. ID-ul: SWING_ANIMATION_ID trebuie să fie textul complet rbxassetid:// cu numărul animației tale, nu un șir gol.
Care e cel mai bun hitbox pentru o sabie în Roblox?
Pentru majoritatea jocurilor, o interogare de cutie pe server o dată per lovitură, ca în acest ghid: un singur apel GetPartBoundsInBox, nimic de falsificat pentru client și trei numere de reglat. Folosește GetPartsInPart cu un part de forma potrivită sau raycasturi de-a lungul lamei doar când raza armei e departe de o cutie. Comparația celor patru metode.
Cum fac ca sabia să nu lovească prin pereți?
Înainte să aplici damage, lansează o rază de la part-ul rădăcină al atacatorului la part-ul rădăcină al țintei, sărind peste personajul atacatorului, și socotește lovitura doar dacă primul lucru întâlnit de rază aparține țintei. Versiunea 2 a SwordService face asta pentru fiecare țintă.
De ce lovitura vine înainte ca animația să ajungă la țintă?
Serverul verifică hitbox-ul în aceeași clipă în care sosește clicul. Așteaptă întâi un avânt scurt, de exemplu 0.15 secunde prin task.delay, apoi verifică faptul că atacatorul e încă viu și ține sabia și construiește cutia, cum face versiunea 2.
Pot exploiterii să trișeze totuși cu această sabie?
Nu pot alege cine e lovit, cât damage face o lovitură și cât de des lovesc, pentru că toate trei le decide serverul; tot ce câștigă sunt 0.1 secunde de rezervă de rețea la cooldown. Își pot mișca în continuare personajul, de exemplu chiar lângă cineva, pentru că fiecare dispozitiv controlează mișcarea propriului personaj. Următorul strat este o verificare a mișcării pe server.
Cum fac un sistem de luptă cu combo?
Ține pe server un contor de lovituri per jucător, resetează-l după o pauză scurtă și alege damage-ul și animația după contor. Verificarea loviturii rămâne aceeași. Secțiunea Cum extinzi mai tratează knockback-ul, uciderile și blocarea.
Surse și lecturi suplimentare
- Roblox Creator Docs: In-game tools (în engleză). construirea unei unelte în Workspace, Handle, Weld, Grip, ancorarea și de ce majoritatea uneltelor folosesc LocalScript, Script și RemoteEvent
- Roblox Creator Docs: WorldRoot:GetPartBoundsInBox (în engleză). interogarea cutiei, OverlapParams și FindPartsInRegion3 învechit
- Roblox Creator Docs: Humanoid:TakeDamage (în engleză). protecția ForceField, bara de viață și refacerea vieții
- Roblox Creator Docs: Network ownership (în engleză). exploitul cu sabia pe Touched
- Roblox Creator Docs: Security tactics and cheat mitigation (în engleză). nu avea niciodată încredere în client
- Roblox Creator Docs: Network ownership, movement validation and physics exploits (în engleză). ce poate face clientul cu personajul lui și verificările de mișcare
- Roblox Creator Docs: Animation Editor (în engleză). prioritatea animației și publicarea
- Roblox Creator Docs: Animator:LoadAnimation (în engleză). ce animații se replică de pe client
- Roblox Creator Docs: Debounce patterns (în engleză). de ce Touched se declanșează de mai multe ori pentru o singură atingere
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.