בקצרה
שימו ב-StarterPack Tool בשם Sword עם פארט בשם Handle. LocalScript ב-Tool מאזין ל-Tool.Activated, מפעיל אנימציית הנפה וקורא ל-RemoteEvent בלי ארגומנטים. Script ב-ServerScriptService בודק את זמן ההמתנה ושהשחקן חי ומחזיק את החרב, מוצא Humanoid בקופסה שלפניו דרך workspace:GetPartBoundsInBox וקורא ל-Humanoid:TakeDamage פעם אחת לכל מטרה.
- אל תגרמו נזק מהאירוע
Touchedשל הלהב: המכשיר של השחקן שולט בדמות שלו ויכול להפעיל Touched מכל מקום, ובדיוק חרב מובאת כדוגמה בעמוד של Roblox על network ownership. - הלקוח לא שולח לא מטרה ולא נזק. זמן ההמתנה, ההיטבוקס וגודל הנזק בידי השרת.
TakeDamageלא עושה כלום כל עוד למטרה יש ForceField, למשל ב-10 השניות הראשונות אחרי לידה על SpawnLocation.- מכות עוברות דרך קירות או נוחתות לפני שההנפה מגיעה למטרה ויזואלית? קחו את הגרסה של סקריפט השרת עם הנפה ובדיקת קירות.
בעמוד הזה
איך בנויה חרב שעובדת
חרב שעובדת במשחק אמיתי מחולקת בין המכשיר של השחקן לבין השרת. בעמוד של Roblox על כלים כתוב שהקלט לכלים צריך לחיות ב-LocalScript, כי רק המכשיר של השחקן יודע מתי הקלט קורה, ושרוב הכלים צריכים LocalScript, Script של שרת ו-RemoteEvent ביניהם. המדריך הזה משתמש בדיוק בחלוקה הזו. הנפה אחת נראית כך:
- השחקן לוחץ, נוגע במסך או לוחץ על ההדק בג׳ויפד כש-Sword מצויד. ב-LocalScript נורה
Tool.Activated. - ה-LocalScript מפעיל את אנימציית ההנפה, אם יש כזו, וקורא ל-RemoteEvent בשם
SwordSwing. הוא לא שולח שום דבר נוסף. - ה-Script של השרת בודק את זמן ההמתנה, שהשחקן חי ושה-Sword בידו.
- השרת בונה היטבוקס משלו לפני הדמות של השחקן ומוצא כל Humanoid בתוכו.
- כל אחד מה-Humanoid האלה מאבד חיים פעם אחת דרך
TakeDamage.
| רכיב | איפה הוא נמצא | מה הוא עושה |
|---|---|---|
Tool Sword | StarterPack | מה שהשחקן מחזיק. Roblox מעתיקה את כל מה שב-StarterPack ל-Backpack של השחקן בכל לידה של הדמות שלו. |
Part Handle | בתוך ה-Tool | הפארט שבו הדמות אוחזת. הלהב מרותך אליו. |
LocalScript SwordClient | בתוך ה-Tool | שומע את הקליק, מפעיל את אנימציית ההנפה וקורא לרימוט. |
RemoteEvent SwordSwing | ReplicatedStorage (SwordService יוצר אותו) | מעביר "הנפתי" מהמכשיר של השחקן לשרת, בלי ארגומנטים. |
Script SwordService | ServerScriptService | בודק כל הנפה, מוצא מי עומד לפני השחקן וגורם נזק. המקום היחיד שבו מכה יכולה לקרות. |
ServerScriptService
SwordService Script new
StarterPack
Sword Tool new
Handle Part new
Blade Part new
WeldConstraint WeldConstraint new
SwordClient LocalScript new
שלב 1: בנו את ה-Tool של החרב
- ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Tool. שנו את השם שלו ל-
Sword. סקריפט השרת מחפש בדיוק את השם הזה. את החרב בונים ב-Workspace, כמו שהעמוד של Roblox על כלים ממליץ, כי שם רואים את הפארטים שלה ואפשר להזיז אותם ולשנות את גודלם. השלב האחרון מעביר אותה ל-StarterPack. - הכניסו ל-Tool Part וקראו לו
Handle. זו הידית שבה הדמות מחזיקה את החרב. הוא חייב להיות צאצא ישיר של ה-Tool והפארט היחיד עם השם הזה: עם שני Handle, Roblox בוחרת אחד באקראי, והדמות עלולה להחזיק את החרב בלהב. - הכניסו ל-Tool Part שני, קראו לו
Blade, תנו לו צורה והציבו אותו כך שיבלוט מהחלק העליון של ה-Handle. - הכניסו ל-Blade WeldConstraint. בחלון Properties קבעו את ה-
Part0שלו ל-Handle ואת ה-Part1ל-Blade, כדי שהחרב תישאר שלמה כשהשחקן נושא אותה. - סמנו את שני הפארטים ובדקו ש-Anchored כבוי. פארט מעוגן בכלי משתק את הדמות במקום כשהיא מציידת אותו. כבו בשניהם גם את CanCollide, כדי שהלהב לא ייתקע בשחקנים ובקירות בזמן הנפה.
- סמנו את ה-Tool והורידו את הסימון מ-CanBeDropped. כשהוא מסומן, לחיצה על Backspace זורקת את החרב ל-Workspace.
- גררו את ה-Sword המוכן מ-Workspace ל-StarterPack. Tool שנשאר ב-Workspace הוא חפץ שאפשר להרים, ששחקן אחד לוקח, ולא חרב שנמצאת מההתחלה ב-Backpack של כולם.
גם חרב מ-MeshPart אחד תתאים: קראו ל-MeshPart הזה Handle ודלגו על ה-Weld. אם בבדיקה הדמות מחזיקה את החרב בזווית מוזרה, סמנו את ה-Tool וכווננו את מאפייני האחיזה שלו (GripPos, GripForward, GripRight ו-GripUp) בחלון Properties.
שלב 2: הוסיפו את סקריפט השרת
רחפו מעל ServerScriptService, הכניסו Script בשם SwordService והדביקו בו את הקוד שלמטה. זה המקום היחיד שבו מכת חרב יכולה לקרות. ההגדרות בהתחלה הן השורות שאתם אמורים לשנות.
-- Script ב-ServerScriptService בשם SwordService.
-- המקום היחיד שבו מכת חרב יכולה לקרות: בודק את ההנפה, מוצא מטרות לפני
-- התוקף עם היטבוקס משלו וגורם נזק.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- הגדרות
local SWORD_NAME = "Sword" -- שם ה-Tool ב-StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- שמרו את אותו ערך ב-SwordClient
local HIT_RANGE = 6 -- studs לפני התוקף
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: שחקנים מאותה קבוצה לא יכולים לפצוע זה את זה
-- הנפות שנשלחו בדיוק במרווח של COOLDOWN_SECONDS יכולות להגיע אחרי השהיית רשת
-- קצת קרובות יותר זו לזו, ולכן השרת נותן מרווח כזה ולא זורק הנפה אמיתית
local NETWORK_SLACK = 0.1
-- הרימוט שה-LocalScript של החרב קורא לו. הוא לא נושא ארגומנטים: מי ייפגע
-- מחליט השרת, ולכן ללקוח אין מה לזייף.
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. הנפה אחת לכל זמן המתנה, לא משנה כמה פעמים קוראים לרימוט
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 עלול למצוא את שלכם, ואף אחד בשרת לא מאזין לו.
| הגדרה | הערך כאן | מה זה משנה |
|---|---|---|
SWORD_NAME | "Sword" | שם ה-Tool שהשרת מצפה למצוא ביד השחקן. שנו אותו אם ל-Tool שלכם קוראים אחרת. |
DAMAGE | 20 | כמה חיים כל מכה מורידה. Humanoid מתחיל עם 100 חיים, ולכן חמש מכות מפילות את ריג הבדיקה. דמויות שחקנים כברירת מחדל משחזרות 1% מה-MaxHealth בכל שנייה, ולכן שחקן שמכים אותו במהירות המרבית שורד את המכה החמישית, וצריך שישית. |
COOLDOWN_SECONDS | 0.6 | הזמן בין הנפות. קבעו את אותו ערך ב-SwordClient. |
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT | 6, 5, 6 | ההיטבוקס ב-studs: כמה רחוק הוא מגיע לפני השחקן, מה הרוחב ומה הגובה שלו. |
FRIENDLY_FIRE | false | ב-false שחקנים מאותה קבוצה לא יכולים לפצוע זה את זה. שחקנים בלי קבוצה תמיד יכולים להכות זה את זה, ו-NPC תמיד אפשר להכות. |
NETWORK_SLACK | 0.1 | בכמה לפני סוף זמן ההמתנה השרת עדיין מקבל הנפה. שני קליקים במרווח של 0.6 שנייה יכולים להגיע אחרי השהיית רשת קצת קרובים יותר זה לזה, ובלי המרווח הזה השרת היה זורק הנפה אמיתית שהשחקן כבר ראה. |
שלב 3: הוסיפו LocalScript ל-Tool
הכניסו ל-Tool בשם Sword LocalScript, קראו לו SwordClient והדביקו בו את הקוד הזה:
-- LocalScript בתוך ה-Tool בשם Sword, בשם SwordClient.
-- 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 מסביר למה כל רימוט צריך להיבדק בשרת, ו-Script vs LocalScript vs ModuleScript (באנגלית) מראה מה LocalScript יכול ומה לא יכול לשנות.
איך השרת מחליט מי נפגע
כש-SwordSwing מגיע, SwordService לא שואל את הלקוח כלום. הוא בונה קופסה לפני הדמות של התוקף במקום שבו השרת רואה אותה, ושואל את המנוע אילו פארטים נמצאים בפנים דרך workspace:GetPartBoundsInBox. המתודה הזו מחליפה את FindPartsInRegion3 הישנה יותר, ש-Roblox מסמנת כמיושנת.
מרכז הקופסה נמצא 3 studs לפני הפארט הראשי של התוקף. זו ההזזה CFrame.new(0, 0, -HIT_RANGE / 2): CFrame מסתכל לאורך ציר ה-Z השלילי שלו, וזה ה-LookVector שלו. לכן הקופסה נמתחת מאמצע הדמות 6 studs קדימה, ברוחב 5 studs ובגובה 6. השאילתה משווה את הקופסה התוחמת (bounding box) של כל פארט, קירוב מהיר של הנפח שלו בצורת קופסה, ולכן פארטים עגולים ומש׳ים נחשבים קצת גדולים ממה שהם נראים. לחרב המרווח הקטן הזה מועיל.
| שלב | קוד | למה |
|---|---|---|
| לדלג על התוקף | OverlapParams עם Exclude והדמות של התוקף | גם הידיים, הרגליים והחרב של התוקף עצמו נמצאים בקופסה. |
| למצוא את הדמות | part:FindFirstAncestorOfClass("Model") | פארט בקופסה יכול להיות איבר, כובע או כלי ביד. FindFirstAncestorOfClass משווה את שם המחלקה המדויק, ולכן עובר על פני כובע (מחלקה Accessory) וכלי ביד (מחלקה Tool, למרות ש-Tool הוא סוג של Model) ונעצר במודל של הדמות. |
| למצוא את ה-Humanoid | model:FindFirstChildOfClass("Humanoid") | אפשר להכות כל דבר שיש לו Humanoid: שחקנים, NPC ובובות בדיקה. קירות ורצפות מדולגים. |
| פעם אחת לכל Humanoid | הטבלה alreadyHit | בקופסה בדרך כלל נמצאים כמה פארטים של אותה דמות. בלי הטבלה כל אחד מהם היה גורם נזק מחדש. |
| רק מטרות חיות | target.Health > 0 | דמות שכבר הופלה לא מקבלת מכה נוספת. |
| קבוצות | isTeammate | כש-FRIENDLY_FIRE שווה false, שחקנים מאותה קבוצה מדולגים. לשחקן שהמאפיין Neutral שלו שווה true אין קבוצה. |
| נזק | target:TakeDamage(DAMAGE) | מוריד Health, אם ForceField לא מגן על המטרה. |
הטבלה alreadyHit נוצרת מחדש בכל הנפה, ולכן אפשר להכות את אותו שחקן שוב בהנפה הבאה, כשזמן ההמתנה עובר. זה הכלל "פעם אחת לכל מטרה בכל הנפה", שחרבות על Touched נאבקות בו כל הזמן.
הסקריפט משתמש ב-TakeDamage, ולא בהשמה ל-Health. בתיעוד של Roblox כתוב ש-TakeDamage לא נוגע ב-Humanoid כל עוד ForceField מגן עליו, והשמה ישירה ל-Health מתעלמת מה-ForceField. שחקן שנולד על SpawnLocation מקבל כברירת מחדל ForceField ל-10 שניות (ה-Duration של SpawnLocation), ולכן אי אפשר להכות שחקנים חדשים ברגע שהם מופיעים.
ארבע דרכים ליצור היטבוקס לחרב: השוואה
מדריכים לחרבות נבדלים בעיקר בדבר אחד: איך לדעת במה הלהב פגע. יש ארבע תשובות נפוצות. הן שונות במידה שבה הן עוקבות אחרי הלהב, בכמה עבודה הן עולות לשרת, ובשאלה אם רמאי יכול לזייף את התוצאה.
| דרך | איך זה עובד | מי מחליט | דיוק | למה הכי מתאים |
|---|---|---|---|---|
Touched על הלהב | נזק בכל פעם שפארט של הלהב נוגע בדמות | המכשיר של התוקף, שהוא הבעלים של הדמות והחרב שלו | עוקב אחרי הלהב, אבל נורה כמה פעמים בכל נגיעה | לשום דבר במשחק עם שחקנים אחרים: המכשיר של התוקף יכול להפעיל אותו מכל מקום |
| קופסה לפני השחקן (המדריך הזה) | שאילתת GetPartBoundsInBox אחת בשרת לכל הנפה | השרת | קופסה קבועה, לא המסלול של הלהב. מש׳ים נחשבים לפי הקופסאות התוחמות שלהם, ולכן קצת בנדיבות | רוב המשחקים: פשוט, זול ואין מה לזייף |
GetPartsInPart על פארט היטבוקס | שאילתת שרת עם פארט בצורת הקשת של הלהב, בזמן ההנפה | השרת | צורות מדויקות: בתיעוד של Roblox כתוב שהוא עושה בדיקה גיאומטרית מלאה, ומוצעות שאילתות קופסה או כדור כשמספיק פחות דיוק, כי הן זולות יותר | נשק גדול בצורה לא רגילה, למשל הקשת של חרמש |
| ריי-קאסטים לאורך הלהב | בכל פריים של ההנפה נורות קרניים קצרות מנקודות על הלהב למקום שבו הן היו בפריים הקודם | הצד שיורה אותן. בשרת צריך ייצוג של השרת למיקום הלהב | עוקב מקרוב אחרי האנימציה | משחקים שבהם המסלול המדויק של ההנפה חשוב. כך עובדים מודולי ההיטבוקס של הקהילה |
קופסה היא הבחירה הראשונה הנכונה. זו שאילתה אחת לכל הנפה, היא אף פעם לא תלויה באנימציה שרמאי יכול לשנות, וקל לכוונן אותה בשלושה מספרים. עברו לפארט בצורה הרצויה או לקרניים לאורך הלהב כששחקנים מתלוננים שהפגיעות מרגישות לא נכון בנשק שהטווח שלו רחוק מקופסה, ושמרו על אותו כלל: את השאילתה מריץ והנזק גורם השרת.
הגדרות מוכנות לחרבות: מפגיון ועד חרב דו-ידנית
אותו SwordService יוצר נשק שונה מאוד בחמש הגדרות. הטבלה היא נקודת התחלה, מחושבת לבובה מ-Rig Generator עם 100 Health. "הזמן עד הפלה" נספר מהמכה הראשונה, כשכל הנפה פוגעת מיד כשזמן ההמתנה מאפשר.
| נשק | DAMAGE | COOLDOWN_SECONDS | HIT_RANGE | HIT_WIDTH | מכות (זמן) | נזק לשנייה |
|---|---|---|---|---|---|---|
| פגיון | 12 | 0.35 | 4 | 4 | 9 (2.8 שנ׳) | בערך 34 |
| חרב (המדריך הזה) | 20 | 0.6 | 6 | 5 | 5 (2.4 שנ׳) | בערך 33 |
| חרב דו-ידנית | 35 | 1.1 | 7 | 7 | 3 (2.2 שנ׳) | בערך 32 |
| חנית | 18 | 0.8 | 9 | 3 | 6 (4 שנ׳) | בערך 23 |
- שחקנים מתרפאים, בובות לא. דמויות שחקנים כברירת מחדל משחזרות 1% מה-MaxHealth בכל שנייה. עם בדיוק 100 נזק ב-5 מכות, שחקן שמכים אותו במהירות המרבית שורד את המכה החמישית, וצריך שישית. השאירו מרווח, למשל 21 נזק במקום 20, אם מספר המכות המדויק חשוב.
- שנו את NETWORK_SLACK יחד עם זמן ההמתנה. ה-0.1 שנייה מהמדריך הם שישית מ-0.6. אם משאירים 0.1 בפגיון עם זמן המתנה של 0.35 שנייה, רמאי יוכל להכות כל 0.25 שנייה, מהר יותר ב-40%. קחו בערך שישית מ-
COOLDOWN_SECONDS: 0.06 לפגיון. - שמרו על SwordClient תואם. קבעו שם את אותו
COOLDOWN_SECONDS, אחרת הלקוח שולח הנפות שהשרת מתעלם מהן.
גרסה 2: הנפה ובלי מכות דרך קירות
כשהחרב הבסיסית עובדת, מופיעות שתי תלונות. המכה נוחתת באותו רגע שהשחקן לחץ, לפני שאנימציית ההנפה מגיעה למטרה, והנפה יכולה להגיע למי שעומד בצד השני של קיר דק, כי הקופסה לא מתחשבת בקיר. הגרסה הזו של SwordService מתקנת את שני הדברים. היא מחליפה את הסקריפט משלב 2: אותו שם, אותו רימוט, אותן הגדרות, ולכן לא צריך לשנות את SwordClient.
-- Script ב-ServerScriptService בשם SwordService (הגרסה עם הנפה ובדיקת קירות).
-- מחליף את הסקריפט משלב 2: אותן הגדרות ורימוט ועוד שני כללים. המכה נוחתת
-- 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)
קודם מחקו את SwordService משלב 2, אחרת שני הסקריפטים ייצרו כל אחד רימוט SwordSwing. קבעו את WINDUP_SECONDS לרגע באנימציית ההנפה שלכם שבו הלהב עובר לפני הדמות; להנפה מהירה מתאים 0.15.
- ההנפה. זמן ההמתנה והבדיקות "חי ומחזיק את החרב" רצים כשהקליק מגיע, ואז
task.delayמפעיל אתstrikeאחריWINDUP_SECONDS.strikeבודק את התוקף שוב, כי בזמן הזה הוא יכול היה למות או להוריד את החרב, ורק אחר כך בונה את הקופסה. מטרה שיצאה מהטווח בזמן ההנפה לא נפגעת, ובדיוק לזה שחקנים מצפים כשהם רואים את ההנפה. - בדיקת קירות. לכל מטרה בקופסה
hasClearLineיורה קרן מהפארט הראשי של התוקף לפארט הראשי של המטרה, ומדלג על הדמות של התוקף עצמו. אם הדבר הראשון שהיא פוגשת שייך למטרה, או שהיא לא פוגשת כלום, המכה נחשבת. קיר, דלת או שחקן אחר ביניהם חוסמים אותה. - כמה זה עולה. קרן נוספת אחת לכל מטרה בכל הנפה, וזה מעט לעומת שאילתת הקופסה עצמה.
ההנפה גם הופכת את החרב להוגנת יותר מול רמאים שמכים באותו רגע שהם משתגרים למישהו: השרת מחפש מטרות רגע אחר כך, במקום שבו הוא רואה את הדמויות באותו רגע. את השיגור עצמו זה לא עוצר; לזה צריך בדיקת תנועה, שמתוארת בפרק מה אקספלויטר יכול ומה לא.
הוסיפו אנימציית הנפה (אופציונלי)
SwordClient כבר מפעיל אנימציה ברגע שתתנו לו ID. את האנימציה יוצרים פעם אחת, ב-Animation Editor ב-Studio:
- הכניסו ריג לאנימציה. בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator, ובחרו ריג שמתאים לאווטארים של המשחק שלכם, למשל R15 ואז Block Avatar.
- בלשונית Avatar לחצו על Clip Editor כדי לפתוח את Animation Editor, סמנו את הריג וקבעו תנוחות להנפה קצרה ביד ימין.
- קבעו עדיפות Action: לחצו על הכפתור … בפקדי הניגון של העורך, רחפו מעל Set Animation Priority ובחרו Action. Action גבוה מ-Movement, Idle ו-Core, ולכן ההנפה רצה מעל אנימציות ההליכה והעמידה, ולא מפסידה להן.
- באותו תפריט … בחרו Publish to Roblox. אם המשחק שלכם שייך לקבוצה, בחרו את הקבוצה הזו בשדה Creator לפני השליחה.
- העתיקו את ה-asset ID של האנימציה מה-Toolbox וב-SwordClient קבעו את
SWING_ANIMATION_IDל-"rbxassetid://"ואחריו המספר הזה.
SwordClient טוען את ההנפה דרך ה-Animator של הדמות, ולא דרך Humanoid:LoadAnimation הישן יותר, ש-Roblox מסמנת כמיושן. בתיעוד של Roblox על Animator כתוב שאנימציות שהמכשיר של שחקן מפעיל על הדמות של השחקן הזה עצמו משוכפלות לשרת ולכל שאר השחקנים, ולכן LocalScript יכול להפעיל את ההנפה, וכולם יראו אותה. שם גם כתוב שה-Animator צריך להיווצר בשרת, ולכן אף פעם אל תיצרו אותו ב-LocalScript. אצל דמויות שחקנים הוא בדרך כלל נמצא בתוך ה-Humanoid, ובדיוק שם מחפשת אותו דוגמת האנימציה של Roblox עצמה.
האנימציה נחוצה רק למראה. הפגיעות לא תלויות בה, ולכן אנימציה איטית, חסרה או משונה אף פעם לא משנה מי ייפגע.
איך להפעיל אנימציה בלחיצת מקש, בלולאה או על NPC, קראו במדריך לסקריפט אנימציה.
במה טועים מדריכים ישנים לחרבות
אם אתם משווים את המדריך הזה לסרטון או לפוסט בפורום, הנה ההבדלים החשובים והסיבה שכל טריק יוצר בעיה.
| מדריך | הבעיה | המדריך הזה |
|---|---|---|
גורם נזק באירוע Touched של הלהב | המכשיר של התוקף יכול להפעיל Touched על החרב שלו מכל מקום (העמוד של Roblox על network ownership), ו-Touched נורה כמה פעמים ברצף בנגיעה אחת (העמוד של Roblox על debounce). | השרת מוצא מטרות עם קופסה משלו, פעם אחת לכל Humanoid בכל הנפה. |
| מוריד Health ב-LocalScript | שינוי ש-LocalScript עושה בדמות של מישהו אחר נשאר במכשיר האחד הזה. | כל הנזק נגרם ב-SwordService. |
משתמש ב-wait(0.5) לזמן ההמתנה | Roblox מסמנת את wait() הגלובלי כמיושן, ובמקומו משתמשים ב-task.wait(), וזמן המתנה שקיים רק בלקוח לא עוצר אף אחד. | משווה זמן os.clock() בשרת. שום דבר לא מחכה. |
מפעיל את ההנפה דרך Humanoid:LoadAnimation | מיושן, ובמקומו משתמשים ב-Animator:LoadAnimation. | טוען את ההנפה דרך Animator. |
מחפש מטרות דרך Region3 ו-FindPartsInRegion3 | מיושן. Roblox ממליצה בפרויקטים חדשים להשתמש ב-GetPartBoundsInBox עם OverlapParams. | משתמש ב-GetPartBoundsInBox. |
שם Script של שרת בתוך ה-Tool, והוא מאזין ל-Activated | החרב של כל שחקן מריצה עותק משלה של קוד השרת, וסקריפטים כאלה הרבה פעמים גורמים נזק ב-Touched (השורה הראשונה). בהגדרות ברירת המחדל Script רץ רק ב-Workspace או ב-ServerScriptService, ולכן Script ב-Tool לא מתחיל לרוץ עד שמציידים את החרב בפעם הראשונה. העמוד של Roblox על כלים מתאר את רוב הכלים כ-LocalScript לקלט, Script של שרת לאפקט ו-RemoteEvent ביניהם. | SwordService אחד ב-ServerScriptService משרת את כל החרבות במשחק. |
מה אקספלויטר יכול ומה לא
הניחו שרמאי שולט בכל מה שבמכשיר שלו. הוא יכול לקרוא ולשנות את ה-LocalScript שלכם, ובמדריך האבטחה של Roblox כתוב שהוא יכול לקרוא ל-RemoteEvent בכל תדירות ועם ארגומנטים שרירותיים. הנה מה שזה אומר לחרב הזו.
| הרמאי מנסה | תוצאה | למה |
|---|---|---|
לקרוא ל-SwordSwing הכי מהר שהקוד שלו יכול, או להשתמש באוטו-קליקר | נחשבת לכל היותר הנפה אחת כל 0.5 שנייה | זמן ההמתנה בשרת הוא 0.6 שנייה פחות 0.1 שנייה של מרווח רשת. המרווח הזה הוא המקסימום שרמאי מרוויח. |
| לשלוח עם הרימוט מטרה, מספר נזק או מיקום | מתעלמים מזה | onSwing קורא רק את השחקן ש-Roblox מכניסה בעצמה. כל דבר אחר שנשלח עם הרימוט אף פעם לא נקרא. |
| לשנות את SwordClient, למשל להסיר את זמן ההמתנה שלו | לא משפיע על השרת | SwordService מחזיק את ההגדרות שלו ב-ServerScriptService, שאף פעם לא נשלח לשחקנים. |
| להכות כשהוא מת או בלי חרב ביד | מתעלמים מזה | SwordService בודק שה-Humanoid שלו חי ושה-Tool בשם Sword נמצא בתוך הדמות שלו, לשם Roblox מעבירה את הכלי בזמן הציוד. |
| להכות מישהו מהצד השני של המפה | שום דבר לא קורה | הקופסה נבנית סביב הדמות של התוקף במקום שבו השרת רואה אותה, ומגיעה רק 6 studs קדימה. |
| להשתגר לשחקן ואז להכות | אפשרי | כל מכשיר שולט בתנועה של הדמות שלו, ו-Roblox מונה שיגור לכל נקודה בין הדברים שלקוח יכול לעשות עם הדמות שלו. בדיקת תנועה בשרת יכולה לזהות את זה. |
| להכות דרך קיר דק | אפשרי בגבולות הקופסה של 6 studs | שאילתת הקופסה משלב 2 לא מחפשת קירות. גרסה 2 מוסיפה בדיקת קירות. |
| להפעיל כל אנימציה או אף אחת | לא משפיע על הפגיעות | הפגיעות אף פעם לא תלויות באנימציה. Roblox מציינת שרמאים יכולים להפעיל אנימציות שרירותיות על הדמות שלהם. |
בשתי שורות כתוב "אפשרי", וזה כן. החרב הזו לא מאפשרת לרמאי לבחור במי הוא מכה, כמה חזק וכמה פעמים. היא לא יכולה למנוע ממנו להזיז את הדמות שלו. בתיעוד האבטחה של Roblox כתוב שלקוחות שולטים בתנועה ובפיזיקה של הדמות שלהם ושצריך לכוונן בדיקות תנועה לכל משחק. למשחק תחרותי השכבה הבאה היא בדיקת תנועה בשרת (המדריך לריצה בונה אחת כזו, היא מזהירה מ-speedhacks גסים ומשיגורים רחוקים) או server authority של Roblox, שהתיעוד תיאר כבטא כשבדקנו ב-13 באוקטובר 2026.
שלב 4: בדקו
- הוסיפו משהו להכות בו. בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator, בחרו ריג (למשל R15, ואז Block Avatar), והוא ייכנס ל-Workspace. הרחיקו אותו כמה studs מה-SpawnLocation שלכם.
- לחצו על Play, ציידו את Sword מה-hotbar, גשו לריג ולחצו. אחרי המכה הראשונה מעליו מופיע פס חיים, כי כברירת מחדל Humanoid מציג פס רק כשה-Health שלו מתחת ל-MaxHealth. Humanoid מתחיל עם 100 חיים, ולכן המכה החמישית מפילה אותו.
- ×××¦× ××× ××ר ש××ª× ××××××. רק ×× ×¤× ××ת ×× 0.6 ×©× ××× ×¢××©× ×ש××.
- התרחקו מהריג בערך 8 studs, או הסתובבו אליו עם הגב, והניפו. שום דבר לא קורה, כי אף פארט שלו לא נמצא בקופסה.
- בדקו על שחקן אמיתי. בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. הכו את השחקן השני בתוך 10 שניות אחרי הלידה שלו: שום דבר לא קורה בגלל ה-ForceField בלידה. אחרי זה כל מכה מורידה 20. כברירת מחדל דמויות שחקנים גם משחזרות 1% מה-MaxHealth בכל שנייה, ולכן בין קרבות החיים שלהן חוזרים לאט.
- אם במשחק שלכם יש Teams, שימו את שני שחקני הבדיקה באותה קבוצה. כש-
FRIENDLY_FIREשווה false, ההנפות שלהם לא עושות כלום זה לזה.
כל הזמן הזה השאירו את חלון ה-Output פתוח (תפריט Window, ואז Output). כשהסקריפטים האלה עובדים, הם לא מדפיסים כלום, ולכן כל שגיאה אדומה מ-SwordService או מ-SwordClient היא בעיה אמיתית. ראו שגיאות נפוצות.
איך להרחיב את החרב למערכת קרב
קומבו
החזיקו בשרת מונה הנפות לכל שחקן, ליד lastSwing. אם ההנפה הקודמת הייתה לא מזמן, הוסיפו 1; אחרת התחילו שוב מ-1. אז בחרו את הנזק לפי המונה, למשל יותר נזק בכל מכה שלישית, ונקו את המונה ב-PlayerRemoving באותה דרך. הלקוח יכול לנהל ספירה משלו כדי לבחור איזו אנימציה להפעיל, כי האנימציה אף פעם לא מחליטה על פגיעה. הקופסה והבדיקות נשארות בדיוק אותו דבר.
הדיפה
אחרי TakeDamage SwordService יכול לדחוף את המטרה דרך ApplyImpulse על ה-RootPart של המטרה, בכיוון ה-rootPart.CFrame.LookVector של התוקף. בתיעוד של Roblox כתוב שהדחיפה תלויה במסה של המטרה, וש-Script של שרת יכול לקרוא לה על פארט שהשרת הוא הבעלים שלו, או על פארט שלקוח הוא הבעלים שלו אוטומטית. המכשיר של כל שחקן מדמה את הדמות שלו עצמו, ולכן בדקו הדיפה על שחקנים דרך Server & Clients, ולא רק על ריג.
ספירת הריגות לטבלת המובילים
מיד לפני target:TakeDamage(DAMAGE) רשמו מי הכה אחרון, דרך target:SetAttribute("LastHitBy", player.UserId). ב-Script של שרת חברו את האירוע Died של ה-Humanoid של כל דמות, קראו את האטריביוט הזה, מצאו את התוקף דרך Players:GetPlayerByUserId והוסיפו 1 ל-IntValue בשם Kills ב-leaderstats שלו. צרו אותו ליד Coins ו-Wins, כמו בשלב 1 של המדריך לטבלת המובילים, ושנו אותו בשרת, כמו בשלב 2.
חסימה
הוסיפו RemoteEvent שני, שהלקוח קורא לו כשכפתור החסימה נלחץ ומשוחרר, ותנו לשרת לקבוע את האטריביוט Blocking על הדמות של השחקן הזה, עם מגבלת תדירות משלו. ב-SwordService הקטינו או דלגו על הנזק כשעל הדמות של המטרה קבוע Blocking. הרמאי עדיין בוחר בעצמו מתי לחסום, ולכן עשו את החסימה קצרה או תנו לה זמן המתנה.
מכירת החרב או חלוקה בכל סיבוב
StarterPack נותן את החרב לכל שחקן בכל לידה. כדי למכור אותה במקום זה, שימו אותה בתיקייה ShopItems מהמדריך ל-GUI של חנות. הקטלוג של המדריך הזה כבר מוכר Tool בשם ClassicSword, ולכן או שתקראו ל-Tool הזה ClassicSword ותקבעו SWORD_NAME זהה, או שתשנו את הרשומה בקטלוג. כדי לחלק אותה רק לזמן סיבוב, קחו את הסקריפט GiveRoundTool מהמדריך למערכת סיבובים: שמרו את Sword ב-ServerStorage, לא ב-StarterPack, והחליפו את "RoundTool" בסקריפט ההוא ב-"Sword".
אויבים לקרב ונשק לטווח רחוק
ל-NPC שרודף אחרי שחקנים, עקבו אחרי המדריך למציאת מסלול ל-NPC. החרב פוגעת בו כמו בכל Humanoid אחר. על נשק שפוגע מרחוק לפי אותם כללי שרת, קראו במדריך לנשק.
שגיאות נפוצות ופתרונות
פתחו את חלון ה-Output (תפריט Window, ואז Output) לפני שלוחצים על Play. רוב הבעיות עם החרב מדפיסות שם שגיאה, או נובעות משם שלא תואם.
Infinite yield possible on 'ReplicatedStorage:WaitForChild("SwordSwing")'
SwordClient מחכה לרימוט ש-SwordService יוצר, כלומר SwordService לא רץ. בדקו שזה Script, לא LocalScript, שהוא נמצא ישירות ב-ServerScriptService, לא מושבת, ושב-Output אין ממנו שגיאה.
אני מניף, אבל אף אחד לא נפגע
בדקו לפי הסדר: SwordClient הוא LocalScript, לא Script, ונמצא ישירות ב-Tool בשם Sword; ל-Tool קוראים בדיוק Sword או מה שמצוין ב-SWORD_NAME; המטרה נמצאת לא יותר מ-6 studs לפניכם; המטרה נולדה לפני יותר מ-10 שניות, כך שה-ForceField שלה כבר נעלם; ואם אתם משתמשים ב-Teams, אתם לא באותה קבוצה כש-FRIENDLY_FIRE שווה false.
החרב פוגעת בשחקנים, אבל אף פעם לא ב-NPC שלי
שאילתות מרחביות כמו GetPartBoundsInBox אף פעם לא מחזירות פארט שבו CanQuery כבוי (CanQuery משפיע רק כש-CanCollide כבוי גם הוא). הפעילו מחדש את CanQuery בחלקי הגוף של ה-NPC ובדקו שה-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 יוצר את ה-Tool, הפארטים והסקריפטים ב-Explorer שלכם, כך שלא צריך להעתיק קוד מחלון הצ׳אט.
תיצור חרב: Tool בשם Sword ב-StarterPack עם Handle ולהב מרותך אליו, LocalScript שקורא ל-RemoteEvent ב-Activated, ו-Script של שרת שבודק זמן המתנה של 0.6 שנייה וגורם 20 נזק לכל Humanoid בקופסה לפני השחקן.
- יוצר את ה-Tool והפארטים שלו עם Create Instance וקובע את המאפיינים שלהם עם Set Property
- כותב את SwordService ו-SwordClient עם Create Script, ויכול קודם לחפש סקריפטי קרב קיימים עם Search Scripts
- הוא מונחה לבדוק את הקומפילציה של כל סקריפט שכתב עם Check Script, שמקמפל את הקוד ב-Studio בלי להריץ (טיפוסים הוא לא בודק)
- מציב נקודת ביטול לפני ואחרי כל קבוצת שינויים, ולכן Ctrl+Z מחזיר קבוצה אחת בכל פעם
RoCode לא יכול ליצור אנימציית הנפה או להעלות אותה: צרו אותה ב-Animation Editor והדביקו את ה-ID שלה. עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה הוא יכול לשלוט בדמות בדיקה, אבל הוא לא לוחץ בחלון התלת-ממד כדי להניף, ולכן את ההנפות אתם בודקים בעצמכם. העמוד איך ליצור משחק Roblox שלם עם RoCode, מערכת אחרי מערכת מראה איפה הנשק נכנס. איך RoCode מתחבר ל-Studio.
שאלות נפוצות
למה החרב שלי פוגעת בשחקן אחד כמה פעמים בהנפה אחת?
כי היא גורמת נזק מ-Touched. בעמוד של Roblox על debounce מצוין ש-Touched נורה כמה פעמים ברצף בנגיעה אחת, וכל פארט של המטרה יכול לגעת בלהב. המדריך הזה מוצא מטרות בשאילתת קופסה אחת לכל הנפה ומנהל רשימה, ולכן כל Humanoid מאבד חיים פעם אחת בכל הנפה.
הנזק של החרב צריך להיות ב-LocalScript או ב-Script?
ב-Script בשרת. נזק שנגרם מ-LocalScript משנה רק את העותק של המשחק אצל השחקן הזה, וכל מה שנמצא במכשיר של השחקן רמאי יכול לשנות. ה-LocalScript צריך רק לשמוע את הקליק, להפעיל את האנימציה ולקרוא ל-RemoteEvent.
איך מוסיפים לחרב אנימציית הנפה?
צרו אותה ב-Animation Editor, קבעו עדיפות Action, פרסמו ב-Roblox והכניסו את ה-asset ID שלה ל-SWING_ANIMATION_ID בתור rbxassetid:// ואחריו המספר. SwordClient מפעיל אותה דרך ה-Animator של הדמות. אנימציות שהמכשיר של שחקן מפעיל על הדמות של השחקן הזה עצמו מוצגות לכולם.
למה אנימציית החרב לא מתנגנת?
בדקו שלושה דברים. עדיפות: Action גבוה מ-Movement, Idle ו-Core, ולכן הנפה עם Action רצה מעל הליכה ועמידה, ועדיפות נמוכה יותר עלולה להפסיד להן. בעלים: אם המשחק שייך לקבוצה, פרסמו את האנימציה כשהקבוצה הזו נבחרה כ-Creator. ID: SWING_ANIMATION_ID צריך להיות הטקסט המלא rbxassetid:// עם המספר של האנימציה שלכם, ולא מחרוזת ריקה.
איזה היטבוקס הכי טוב לחרב ב-Roblox?
לרוב המשחקים זו שאילתת קופסה בשרת פעם אחת לכל הנפה, כמו במדריך הזה: קריאה אחת ל-GetPartBoundsInBox, ללקוח אין מה לזייף, ושלושה מספרים לכוונון. השתמשו ב-GetPartsInPart עם פארט בצורה הרצויה או בריי-קאסטים לאורך הלהב רק כשהטווח של הנשק רחוק מקופסה. השוואה של ארבע הדרכים.
איך גורמים לחרב לא לפגוע דרך קירות?
לפני שגורמים נזק, ירו קרן מהפארט הראשי של התוקף לפארט הראשי של המטרה, תוך דילוג על הדמות של התוקף, וספרו את המכה רק אם הדבר הראשון שהקרן פוגשת שייך למטרה. גרסה 2 של SwordService עושה את זה לכל מטרה.
למה המכה נוחתת לפני שאנימציית ההנפה מגיעה למטרה?
השרת בודק את ההיטבוקס באותו רגע שהקליק מגיע. קודם חכו הנפה קצרה, למשל 0.15 שנייה דרך task.delay, ואז בדקו שהתוקף עדיין חי ומחזיק את החרב, ובנו את הקופסה, כמו שגרסה 2 עושה.
אקספלויטרים עדיין יכולים לרמות עם החרב הזו?
הם לא יכולים לבחור מי ייפגע, כמה נזק מכה גורמת וכמה פעמים הם מכים, כי את שלושת הדברים מחליט השרת; המקסימום שהם מרוויחים הוא 0.1 שנייה של מרווח רשת בזמן ההמתנה. הם עדיין יכולים להזיז את הדמות שלהם, למשל צמוד למישהו, כי כל מכשיר שולט בתנועה של הדמות שלו. השכבה הבאה היא בדיקת תנועה בשרת.
איך יוצרים מערכת קרב עם קומבו?
החזיקו בשרת מונה הנפות לכל שחקן, אפסו אותו אחרי הפסקה קצרה ובחרו נזק ואנימציה לפי המונה. בדיקת הפגיעה נשארת אותו דבר. הפרק איך להרחיב מפרט גם הדיפה, ספירת הריגות וחסימה.
מקורות וקריאה נוספת
- Roblox Creator Docs: In-game tools (באנגלית). בניית כלי ב-Workspace, Handle, Weld, Grip, עיגון ולמה רוב הכלים משתמשים ב-LocalScript, Script ו-RemoteEvent
- Roblox Creator Docs: WorldRoot:GetPartBoundsInBox (באנגלית). שאילתת קופסה, OverlapParams ו-FindPartsInRegion3 המיושן
- Roblox Creator Docs: Humanoid:TakeDamage (באנגלית). הגנת ForceField, פס החיים ושחזור החיים
- Roblox Creator Docs: Network ownership (באנגלית). האקספלויט עם חרב על Touched
- Roblox Creator Docs: Security tactics and cheat mitigation (באנגלית). אף פעם אל תסמכו על הלקוח
- Roblox Creator Docs: Network ownership, movement validation and physics exploits (באנגלית). מה לקוח יכול לעשות עם הדמות שלו ובדיקות תנועה
- Roblox Creator Docs: Animation Editor (באנגלית). עדיפות אנימציה ופרסום
- Roblox Creator Docs: Animator:LoadAnimation (באנגלית). אילו אנימציות משוכפלות מהלקוח
- Roblox Creator Docs: Debounce patterns (באנגלית). למה Touched נורה כמה פעמים בנגיעה אחת
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.