מדריך · מערכות משחק

איך ליצור חרב ב-Roblox Studio

חרב ב-Roblox היא Tool עם שלוש משימות שמחולקות בין שני סקריפטים: המכשיר של השחקן מזהה את הקליק ומפעיל את ההנפה, והשרת מחליט מי נפגע וכמה חיים הוא איבד. במדריך הזה נבנה את שני הסקריפטים, עם זמן המתנה והיטבוקס ששחקנים לא יכולים לזייף, ונראה איפה האנימציה נכנסת.

עודכן 20 בנובמבר 202619 דק׳ קריאהמאת:

בקצרה

שימו ב-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.
  • מכות עוברות דרך קירות או נוחתות לפני שההנפה מגיעה למטרה ויזואלית? קחו את הגרסה של סקריפט השרת עם הנפה ובדיקת קירות.
בעמוד הזה
  1. איך זה בנוי
  2. 1. בונים את ה-Tool
  3. 2. סקריפט השרת
  4. 3. LocalScript
  5. היטבוקס
  6. סוגי היטבוקס
  7. הנפה ובדיקת קירות
  8. אנימציית הנפה
  9. מדריכים ישנים
  10. גבולות ההגנה
  11. 4. בדיקה
  12. הרחבות
  13. Common errors
  14. עם RoCode
  15. שאלות נפוצות
  16. מקורות וקריאה נוספת

איך בנויה חרב שעובדת

איורהנפות במרווח של לפחות 0.6 שנייה מורידות 20 חיים כל אחת, קליק בתוך זמן ההמתנה לא עושה כלום, והמכה החמישית מפילה את הריג.

חרב שעובדת במשחק אמיתי מחולקת בין המכשיר של השחקן לבין השרת. בעמוד של Roblox על כלים כתוב שהקלט לכלים צריך לחיות ב-LocalScript, כי רק המכשיר של השחקן יודע מתי הקלט קורה, ושרוב הכלים צריכים LocalScript, Script של שרת ו-RemoteEvent ביניהם. המדריך הזה משתמש בדיוק בחלוקה הזו. הנפה אחת נראית כך:

  1. השחקן לוחץ, נוגע במסך או לוחץ על ההדק בג׳ויפד כש-Sword מצויד. ב-LocalScript נורה Tool.Activated.
  2. ה-LocalScript מפעיל את אנימציית ההנפה, אם יש כזו, וקורא ל-RemoteEvent בשם SwordSwing. הוא לא שולח שום דבר נוסף.
  3. ה-Script של השרת בודק את זמן ההמתנה, שהשחקן חי ושה-Sword בידו.
  4. השרת בונה היטבוקס משלו לפני הדמות של השחקן ומוצא כל Humanoid בתוכו.
  5. כל אחד מה-Humanoid האלה מאבד חיים פעם אחת דרך TakeDamage.
ממה מורכבת החרב
רכיבאיפה הוא נמצאמה הוא עושה
Tool SwordStarterPackמה שהשחקן מחזיק. Roblox מעתיקה את כל מה שב-StarterPack ל-Backpack של השחקן בכל לידה של הדמות שלו.
Part Handleבתוך ה-Toolהפארט שבו הדמות אוחזת. הלהב מרותך אליו.
LocalScript SwordClientבתוך ה-Toolשומע את הקליק, מפעיל את אנימציית ההנפה וקורא לרימוט.
RemoteEvent SwordSwingReplicatedStorage (SwordService יוצר אותו)מעביר "הנפתי" מהמכשיר של השחקן לשרת, בלי ארגומנטים.
Script SwordServiceServerScriptServiceבודק כל הנפה, מוצא מי עומד לפני השחקן וגורם נזק. המקום היחיד שבו מכה יכולה לקרות.
ה-Explorer כשהחרב מוכנה. SwordService מוסיף RemoteEvent בשם SwordSwing ל-ReplicatedStorage כשהמשחק רץ.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

שלב 1: בנו את ה-Tool של החרב

  1. ב-Explorer רחפו מעל Workspace, לחצו על כפתור ה-+ והכניסו Tool. שנו את השם שלו ל-Sword. סקריפט השרת מחפש בדיוק את השם הזה. את החרב בונים ב-Workspace, כמו שהעמוד של Roblox על כלים ממליץ, כי שם רואים את הפארטים שלה ואפשר להזיז אותם ולשנות את גודלם. השלב האחרון מעביר אותה ל-StarterPack.
  2. הכניסו ל-Tool Part וקראו לו Handle. זו הידית שבה הדמות מחזיקה את החרב. הוא חייב להיות צאצא ישיר של ה-Tool והפארט היחיד עם השם הזה: עם שני Handle, Roblox בוחרת אחד באקראי, והדמות עלולה להחזיק את החרב בלהב.
  3. הכניסו ל-Tool Part שני, קראו לו Blade, תנו לו צורה והציבו אותו כך שיבלוט מהחלק העליון של ה-Handle.
  4. הכניסו ל-Blade WeldConstraint. בחלון Properties קבעו את ה-Part0 שלו ל-Handle ואת ה-Part1 ל-Blade, כדי שהחרב תישאר שלמה כשהשחקן נושא אותה.
  5. סמנו את שני הפארטים ובדקו ש-Anchored כבוי. פארט מעוגן בכלי משתק את הדמות במקום כשהיא מציידת אותו. כבו בשניהם גם את CanCollide, כדי שהלהב לא ייתקע בשחקנים ובקירות בזמן הנפה.
  6. סמנו את ה-Tool והורידו את הסימון מ-CanBeDropped. כשהוא מסומן, לחיצה על Backspace זורקת את החרב ל-Workspace.
  7. גררו את ה-Sword המוכן מ-Workspace ל-StarterPack. Tool שנשאר ב-Workspace הוא חפץ שאפשר להרים, ששחקן אחד לוקח, ולא חרב שנמצאת מההתחלה ב-Backpack של כולם.

גם חרב מ-MeshPart אחד תתאים: קראו ל-MeshPart הזה Handle ודלגו על ה-Weld. אם בבדיקה הדמות מחזיקה את החרב בזווית מוזרה, סמנו את ה-Tool וכווננו את מאפייני האחיזה שלו (GripPos, GripForward, GripRight ו-GripUp) בחלון Properties.

שלב 2: הוסיפו את סקריפט השרת

רחפו מעל ServerScriptService, הכניסו Script בשם SwordService והדביקו בו את הקוד שלמטה. זה המקום היחיד שבו מכת חרב יכולה לקרות. ההגדרות בהתחלה הן השורות שאתם אמורים לשנות.

Script בתוך ServerScriptService בשם 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 עלול למצוא את שלכם, ואף אחד בשרת לא מאזין לו.

ההגדרות בתחילת SwordService
הגדרההערך כאןמה זה משנה
SWORD_NAME"Sword"שם ה-Tool שהשרת מצפה למצוא ביד השחקן. שנו אותו אם ל-Tool שלכם קוראים אחרת.
DAMAGE20כמה חיים כל מכה מורידה. Humanoid מתחיל עם 100 חיים, ולכן חמש מכות מפילות את ריג הבדיקה. דמויות שחקנים כברירת מחדל משחזרות 1% מה-MaxHealth בכל שנייה, ולכן שחקן שמכים אותו במהירות המרבית שורד את המכה החמישית, וצריך שישית.
COOLDOWN_SECONDS0.6הזמן בין הנפות. קבעו את אותו ערך ב-SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6ההיטבוקס ב-studs: כמה רחוק הוא מגיע לפני השחקן, מה הרוחב ומה הגובה שלו.
FRIENDLY_FIREfalseב-false שחקנים מאותה קבוצה לא יכולים לפצוע זה את זה. שחקנים בלי קבוצה תמיד יכולים להכות זה את זה, ו-NPC תמיד אפשר להכות.
NETWORK_SLACK0.1בכמה לפני סוף זמן ההמתנה השרת עדיין מקבל הנפה. שני קליקים במרווח של 0.6 שנייה יכולים להגיע אחרי השהיית רשת קצת קרובים יותר זה לזה, ובלי המרווח הזה השרת היה זורק הנפה אמיתית שהשחקן כבר ראה.

שלב 3: הוסיפו LocalScript ל-Tool

הכניסו ל-Tool בשם Sword LocalScript, קראו לו SwordClient והדביקו בו את הקוד הזה:

LocalScript בתוך ה-Tool בשם Sword ב-StarterPack בשם 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) של כל פארט, קירוב מהיר של הנפח שלו בצורת קופסה, ולכן פארטים עגולים ומש׳ים נחשבים קצת גדולים ממה שהם נראים. לחרב המרווח הקטן הזה מועיל.

מה SwordService עושה עם הפארטים בקופסה
שלבקודלמה
לדלג על התוקףOverlapParams עם Exclude והדמות של התוקףגם הידיים, הרגליים והחרב של התוקף עצמו נמצאים בקופסה.
למצוא את הדמותpart:FindFirstAncestorOfClass("Model")פארט בקופסה יכול להיות איבר, כובע או כלי ביד. FindFirstAncestorOfClass משווה את שם המחלקה המדויק, ולכן עובר על פני כובע (מחלקה Accessory) וכלי ביד (מחלקה Tool, למרות ש-Tool הוא סוג של Model) ונעצר במודל של הדמות.
למצוא את ה-Humanoidmodel: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. "הזמן עד הפלה" נספר מהמכה הראשונה, כשכל הנפה פוגעת מיד כשזמן ההמתנה מאפשר.

הגדרות SwordService לנשקי קרב פנים אל פנים נפוצים, עם מספר המכות והזמן עד הפלת בובה עם 100 Health. מחושב, לא נמדד
נשקDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHמכות (זמן)נזק לשנייה
פגיון120.35449 (2.8 שנ׳)בערך 34
חרב (המדריך הזה)200.6655 (2.4 שנ׳)בערך 33
חרב דו-ידנית351.1773 (2.2 שנ׳)בערך 32
חנית180.8936 (4 שנ׳)בערך 23
  • שחקנים מתרפאים, בובות לא. דמויות שחקנים כברירת מחדל משחזרות 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
-- 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:

  1. הכניסו ריג לאנימציה. בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator, ובחרו ריג שמתאים לאווטארים של המשחק שלכם, למשל R15 ואז Block Avatar.
  2. בלשונית Avatar לחצו על Clip Editor כדי לפתוח את Animation Editor, סמנו את הריג וקבעו תנוחות להנפה קצרה ביד ימין.
  3. קבעו עדיפות Action: לחצו על הכפתור … בפקדי הניגון של העורך, רחפו מעל Set Animation Priority ובחרו Action. Action גבוה מ-Movement, Idle ו-Core, ולכן ההנפה רצה מעל אנימציות ההליכה והעמידה, ולא מפסידה להן.
  4. באותו תפריט … בחרו Publish to Roblox. אם המשחק שלכם שייך לקבוצה, בחרו את הקבוצה הזו בשדה Creator לפני השליחה.
  5. העתיקו את ה-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 בכל תדירות ועם ארגומנטים שרירותיים. הנה מה שזה אומר לחרב הזו.

מה רמאי יכול לנסות ומה SwordService עושה עם זה
הרמאי מנסהתוצאהלמה
לקרוא ל-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: בדקו

  1. הוסיפו משהו להכות בו. בלשונית Avatar או Home לחצו על Character כדי לפתוח את Rig Generator, בחרו ריג (למשל R15, ואז Block Avatar), והוא ייכנס ל-Workspace. הרחיקו אותו כמה studs מה-SpawnLocation שלכם.
  2. לחצו על Play, ציידו את Sword מה-hotbar, גשו לריג ולחצו. אחרי המכה הראשונה מעליו מופיע פס חיים, כי כברירת מחדל Humanoid מציג פס רק כשה-Health שלו מתחת ל-MaxHealth. Humanoid מתחיל עם 100 חיים, ולכן המכה החמישית מפילה אותו.
  3. לחצו הכי מהר שאתם יכולים. רק הנפה אחת כל 0.6 שנייה עושה משהו.
  4. התרחקו מהריג בערך 8 studs, או הסתובבו אליו עם הגב, והניפו. שום דבר לא קורה, כי אף פארט שלו לא נמצא בקופסה.
  5. בדקו על שחקן אמיתי. בחרו Server & Clients ברשימה הנפתחת של מצבי הבדיקה, קבעו 2 לקוחות ולחצו על Play. הכו את השחקן השני בתוך 10 שניות אחרי הלידה שלו: שום דבר לא קורה בגלל ה-ForceField בלידה. אחרי זה כל מכה מורידה 20. כברירת מחדל דמויות שחקנים גם משחזרות 1% מה-MaxHealth בכל שנייה, ולכן בין קרבות החיים שלהן חוזרים לאט.
  6. אם במשחק שלכם יש 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 בקופסה לפני השחקן.

RoCode עושה
  • יוצר את ה-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 שנייה של מרווח רשת בזמן ההמתנה. הם עדיין יכולים להזיז את הדמות שלהם, למשל צמוד למישהו, כי כל מכשיר שולט בתנועה של הדמות שלו. השכבה הבאה היא בדיקת תנועה בשרת.

איך יוצרים מערכת קרב עם קומבו?

החזיקו בשרת מונה הנפות לכל שחקן, אפסו אותו אחרי הפסקה קצרה ובחרו נזק ואנימציה לפי המונה. בדיקת הפגיעה נשארת אותו דבר. הפרק איך להרחיב מפרט גם הדיפה, ספירת הריגות וחסימה.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.