מדריך · פרסים

איך ליצור פרסים יומיים ב-Roblox Studio

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

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

בקצרה

שמרו לכל שחקן שני מספרים ב-DataStore: last, ערך ה-os.time() של הקבלה האחרונה, ו-streak. אפשר לקבל את הפרס כשעברו 24 שעות. אם עברו יותר מ-48 שעות, הרצף מתחיל מחדש מיום 1; אחרת הוא גדל ביום אחד ועובר במחזור של 7 ימים עם פרסים שגדלים. עשו את הבדיקה בתוך UpdateAsync, כדי שההחלטה והשמירה יקרו יחד.

  • השתמשו ב-os.time() בשרת, ולא בזמן שהלקוח שולח.
  • בתוך UpdateAsync החזירו nil כשאי אפשר לקבל את הפרס: השמירה מתבטלת, ושום דבר לא ניתן.
  • הלקוח רק מבקש את הסטטוס ומבקש את הפרס; השרת עונה.
בעמוד הזה
  1. איך זה עובד
  2. 1. השרת
  3. 2. הכפתור
  4. Common errors
  5. With RoCode
  6. שאלות נפוצות
  7. מקורות וקריאה נוספת

איך פרסים יומיים ורצפים עובדים

מה קורה בקבלה, לפי הזמן שעבר מהפעם הקודמת
זמן מאז הקבלה האחרונהתוצאה
פחות מ-24 שעותעוד מוקדם. הכפתור מציג ספירה לאחור.
בין 24 ל-48 שעותאפשר לקבל את הפרס, והרצף גדל ביום אחד.
יותר מ-48 שעותאפשר לקבל את הפרס, והרצף מתחיל מחדש מיום 1.
אחרי יום 7הקבלה הבאה היא יום 1 של שבוע חדש.

os.time() בשרת מחזיר את זמן Unix הנוכחי בשניות לפי UTC, ולכן כל השרתים מסכימים איתו. השעון במחשב של השחקן לא משתתף, ולכן שינוי התאריך בטלפון לא עוזר.

שלב 1: שרת הפרסים

הפעילו את Enable Studio Access to API Services ב-Game Settings, Security (הפלייס חייב להיות מפורסם). אחר כך הכניסו Script ל-ServerScriptService בשם DailyRewards:

Script בתוך ServerScriptService בשם DailyRewards
-- Script ב-ServerScriptService בשם DailyRewards.
-- פרס אחד פעם ב-24 שעות. אם מקבלים שוב בתוך 48 שעות, הרצף ממשיך,
-- והפרסים גדלים בכל יום במשך שבוע, ואז השבוע מתחיל מחדש.
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local REWARDS = { 50, 75, 100, 150, 200, 300, 500 } -- מטבעות לימים 1 עד 7 של הרצף
local CLAIM_EVERY = 24 * 60 * 60 -- שניות בין קבלות
local STREAK_LOST_AFTER = 48 * 60 * 60 -- פספסו יום שלם, והרצף מתחיל מחדש

type Record = { last: number, streak: number }

local store = DataStoreService:GetDataStore("DailyRewards_v1")
local statusFunction = Instance.new("RemoteFunction")
statusFunction.Name = "GetDailyStatus"
statusFunction.Parent = ReplicatedStorage
local claimFunction = Instance.new("RemoteFunction")
claimFunction.Name = "ClaimDaily"
claimFunction.Parent = ReplicatedStorage

local records: { [Player]: Record } = {}
local claiming: { [Player]: boolean } = {}

local function readRecord(data: any): Record
	if type(data) == "table" and type(data.last) == "number" and type(data.streak) == "number" then
		return { last = data.last, streak = data.streak }
	end
	return { last = 0, streak = 0 }
end

-- יום הרצף לקבלה הבאה, מ-1 עד 7
local function nextDay(record: Record, now: number): number
	if now - record.last >= STREAK_LOST_AFTER then
		return 1
	end
	return record.streak % #REWARDS + 1
end

local function addCoins(player: Player, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += amount
	end
end

Players.PlayerAdded:Connect(function(player: Player)
	local ok, data = pcall(function()
		return store:GetAsync(tostring(player.UserId))
	end)
	if ok then
		records[player] = readRecord(data)
	else
		warn("DailyRewards: could not load", player.Name, data)
	end
end)

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

-- מה התפריט מציג: שניות עד הקבלה הבאה (0 = אפשר עכשיו) ואיזה יום זה
statusFunction.OnServerInvoke = function(player: Player)
	local record = records[player]
	if not record then
		return nil
	end
	local now = os.time()
	return {
		wait = math.max(0, record.last + CLAIM_EVERY - now),
		day = nextDay(record, now),
		rewards = REWARDS,
	}
end

claimFunction.OnServerInvoke = function(player: Player): string
	local record = records[player]
	if not record then
		return "Still loading, try again in a moment"
	end
	if claiming[player] then
		return "One moment..."
	end
	claiming[player] = true
	local now = os.time()
	local claimedDay: number? = nil
	-- UpdateAsync קורא את הרשומה השמורה העדכנית ביותר ומחליט בתוך העדכון, ולכן
	-- שרת שני (או לחיצה שנייה) לא יכול לקבל את אותו יום פעמיים
	local ok, err = pcall(function()
		store:UpdateAsync(tostring(player.UserId), function(old: any)
			-- UpdateAsync יכול לקרוא לזה כמה פעמים: נחשבת רק הקריאה האחרונה
			claimedDay = nil
			local saved = readRecord(old)
			if now - saved.last < CLAIM_EVERY then
				return nil -- עוד מוקדם: החזרת nil מבטלת את השמירה
			end
			local day = nextDay(saved, now)
			claimedDay = day
			return { last = now, streak = day }
		end)
	end)
	claiming[player] = nil
	if not ok then
		warn("DailyRewards: could not save", player.Name, err)
		return "Could not save, try again later"
	end
	local day = claimedDay
	if not day then
		return "Come back later for your next reward"
	end
	records[player] = { last = now, streak = day }
	addCoins(player, REWARDS[day])
	return string.format("Day %d reward: +%d coins!", day, REWARDS[day])
end

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

שלב 2: כפתור עם ספירה לאחור

הכניסו LocalScript ל-StarterPlayer > StarterPlayerScripts בשם DailyRewardsMenu:

LocalScript בתוך StarterPlayerScripts בשם DailyRewardsMenu
-- LocalScript ב-StarterPlayerScripts בשם DailyRewardsMenu.
-- כפתור Daily עם ספירה לאחור. כשהפרס מוכן, כתוב עליו Claim.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local statusFunction = ReplicatedStorage:WaitForChild("GetDailyStatus") :: RemoteFunction
local claimFunction = ReplicatedStorage:WaitForChild("ClaimDaily") :: RemoteFunction

local gui = Instance.new("ScreenGui")
gui.Name = "DailyGui"
gui.ResetOnSpawn = false
local button = Instance.new("TextButton")
button.Size = UDim2.fromOffset(170, 48)
button.Position = UDim2.new(0, 12, 0.5, 52)
button.BackgroundColor3 = Color3.fromRGB(240, 170, 40)
button.TextColor3 = Color3.new(1, 1, 1)
button.Font = Enum.Font.GothamBold
button.TextSize = 17
button.Text = "Daily reward"
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = button
button.Parent = gui
gui.Parent = Players.LocalPlayer:WaitForChild("PlayerGui")

local readyAt: number? = nil -- זמן os.clock() שבו הפרס יהיה מוכן
local day = 1
local busy = false

local function refresh()
	local ok, status = pcall(function()
		return statusFunction:InvokeServer()
	end)
	if ok and type(status) == "table" and type(status.wait) == "number" then
		readyAt = os.clock() + status.wait
		day = if type(status.day) == "number" then status.day else 1
	end
end

local function format(seconds: number): string
	local h = seconds // 3600
	local m = (seconds % 3600) // 60
	local s = seconds % 60
	return string.format("%02d:%02d:%02d", h, m, s)
end

button.Activated:Connect(function()
	if busy or not readyAt or os.clock() < readyAt then
		return
	end
	busy = true
	button.Text = "Claiming..."
	local ok, message = pcall(function()
		return claimFunction:InvokeServer()
	end)
	button.Text = if ok and type(message) == "string" then message else "Try again"
	task.wait(2)
	refresh()
	busy = false
end)

refresh()
while true do
	if not busy then
		if not readyAt then
			button.Text = "Loading..."
			refresh()
		elseif os.clock() >= readyAt then
			button.Text = string.format("Claim day %d!", day)
		else
			button.Text = "Next: " .. format(math.ceil(readyAt - os.clock()))
		end
	end
	task.wait(1)
end

הכפתור שואל את השרת פעם אחת כמה לחכות, ואז סופר לבד כל שנייה דרך os.clock(), ולכן הוא לא פונה לשרת כל שנייה. אחרי הקבלה הוא שואל שוב. הספירה לאחור היא רק בשביל המראה: השרת בכל מקרה בודק את הזמן כשהשחקן לוחץ על Claim.

בדקו

  1. לבדיקה קבעו את CLAIM_EVERY ל-30 ואת STREAK_LOST_AFTER ל-60.
  2. לחצו על Play. על הכפתור כתוב "Claim day 1!". לחצו עליו: +50 מטבעות.
  3. הכפתור סופר 30 שניות לאחור. קבלו שוב בתוך 30 השניות הבאות: יום 2, +75.
  4. חכו יותר מדקה: הקבלה הבאה שוב תהיה יום 1.
  5. לפני הפרסום החזירו את שני הערכים לשורות של 24 ו-48 שעות.

שגיאות נפוצות ופתרונות

עקבו אחרי חלון ה-Output במצב Server.

הכפתור כל הזמן מציג Loading...

הרשומה של השחקן לא נטענה. ב-Studio הפעילו את Enable Studio Access to API Services. ב-Output השגיאה מופיעה אחרי "could not load".

בקבלה כתוב "Come back later", למרות שעל הכפתור היה Claim

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

הרצף מתאפס כל יום

השחקנים מקבלים את הפרס בהפרש של יותר מ-48 שעות, או ש-STREAK_LOST_AFTER נשאר עם ערך הבדיקה.

מטבעות לא נוספים

לשחקן צריך להיות IntValue בשם Coins בתוך leaderstats, שנוצר על ידי סקריפט שרת.

בנו את זה עם RoCode

אם אתם לא רוצים להגדיר את זה ביד, RoCode יכול לבנות את זה בפלייס שפתוח אצלכם. RoCode הוא סוכן AI עצמאי ל-Roblox Studio, לא של Roblox: אתם מתארים את השינוי בצ׳אט באתר, והפלאגין שלו ל-Studio יוצר סקריפטים ב-Explorer שלכם.

אתם כותבים

תוסיף פרסים יומיים עם רצף של 7 ימים: מטבעות בימים 1 עד 6 ו-Gem ביום 7, כפתור עם ספירה לאחור, עם שמירה ובדיקה בשרת.

RoCode עושה
  • יכול להכניס בשלב אחד מסך פרסים יומיים מונפש ומוכן מערכות ה-UI הפרימיום שלו, באחת מחמש ערכות נושא (candy, neon, gold, blocky, pastel), עם סקריפטי שרת שעובדים
  • או כותב את סקריפט השרת ואת הכפתור מהמדריך הזה, מחוברים למטבע הקיים שלכם
  • הוא מונחה לבדוק את הקומפילציה של כל סקריפט עם Check Script, ומציב נקודות ביטול סביב כל קבוצת שינויים

אחרי הבנייה RoCode יכול להפעיל את רובוט הבדיקה שלו: הוא משחק במשחק שלכם ב-Studio, לוחץ על כפתורים ומדווח PASS או FAIL. הוא בודק רק את מה שהוא עצמו בחר לבדוק, ולטיימר של 24 שעות צריך בדיקה משלכם עם ערכים קצרים. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

איך יוצרים פרסים יומיים ב-Roblox?

שמרו את זמן הקבלה האחרון של כל שחקן דרך os.time() בשרת, אפשרו קבלה אחרי 24 שעות ושמרו אותה בתוך UpdateAsync לפני מתן הפרס. הסקריפט בשלב 1.

איך יוצרים רצף כניסות יומי?

שמרו את מונה הרצף יחד עם זמן הקבלה. אם הקבלה הבאה הגיעה בתוך 48 שעות, הוסיפו אחד; אם מאוחר יותר, התחילו מחדש מ-1.

שחקנים יכולים לרמות את הפרסים היומיים על ידי שינוי השעון?

עם הסקריפט הזה לא: הוא משתמש רק ב-os.time() של השרת.

אולי עדיף לאפס את הפרס בחצות?

אפשר לספור ימים קלנדריים לפי UTC במקום 24 שעות. 24 שעות נעות פשוטות יותר ועובדות אותו דבר לכל אזורי הזמן.

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

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

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

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