בקצרה
שמרו לכל שחקן שני מספרים ב-DataStore: last, ערך ה-os.time() של הקבלה האחרונה, ו-streak. אפשר לקבל את הפרס כשעברו 24 שעות. אם עברו יותר מ-48 שעות, הרצף מתחיל מחדש מיום 1; אחרת הוא גדל ביום אחד ועובר במחזור של 7 ימים עם פרסים שגדלים. עשו את הבדיקה בתוך UpdateAsync, כדי שההחלטה והשמירה יקרו יחד.
- השתמשו ב-
os.time()בשרת, ולא בזמן שהלקוח שולח. - בתוך UpdateAsync החזירו nil כשאי אפשר לקבל את הפרס: השמירה מתבטלת, ושום דבר לא ניתן.
- הלקוח רק מבקש את הסטטוס ומבקש את הפרס; השרת עונה.
איך פרסים יומיים ורצפים עובדים
| זמן מאז הקבלה האחרונה | תוצאה |
|---|---|
| פחות מ-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.
-- פרס אחד פעם ב-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.
-- כפתור 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.
בדקו
- לבדיקה קבעו את
CLAIM_EVERYל-30ואתSTREAK_LOST_AFTERל-60. - לחצו על Play. על הכפתור כתוב "Claim day 1!". לחצו עליו: +50 מטבעות.
- הכפתור סופר 30 שניות לאחור. קבלו שוב בתוך 30 השניות הבאות: יום 2, +75.
- חכו יותר מדקה: הקבלה הבאה שוב תהיה יום 1.
- לפני הפרסום החזירו את שני הערכים לשורות של 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, כפתור עם ספירה לאחור, עם שמירה ובדיקה בשרת.
- יכול להכניס בשלב אחד מסך פרסים יומיים מונפש ומוכן מערכות ה-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 שעות נעות פשוטות יותר ועובדות אותו דבר לכל אזורי הזמן.
מקורות וקריאה נוספת
- Roblox Creator Docs: GlobalDataStore:UpdateAsync (באנגלית). פונקציית העדכון וביטול דרך nil
- Roblox Creator Docs: Data stores (באנגלית). גישה מ-Studio ויסודות data store
- Roblox Creator Docs: Remote events and functions (באנגלית). RemoteFunction
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.