Eğitim · Oyun sistemleri

Roblox Studio'da envanter sistemi nasıl yapılır

Bir envanter bir UI işi gibi görünür, ama hile yapılıp yapılamayacağına ya da eşya kaybedip kaybetmediğine eşyaların nerede durduğu karar verir. Bu rehberde her oyuncunun eşyaları sunucuda bir tabloda duruyor, her oyuncu bir kopya alıp onu ızgara olarak çiziyor, sunucunun kontrol ettiği isteklerle Tool kuşanıyor ve tüketilebilir eşyaları kullanıyor, her şey de bir data store'a kaydediliyor.

Güncellendi: 20 Kasım 202613 dk okumaYazan:

Kısaca

Her oyuncunun eşyalarını sunucuda bir tabloda, onları eklemeye, çıkarmaya ya da yığmaya izni olan tek kod olan bir ServerScriptService'teki ModuleScript içinde tut. Eşyalarını bir kez bir ReplicatedStorage'taki ModuleScript içinde listele (id, ad, en fazla yığın). Her değişiklikten sonra sunucu o oyuncuya envanterinin bir kopyasıyla bir RemoteEvent tetikler ve bir LocalScript onu bir ScrollingFrame ve bir UIGridLayout ile ızgara olarak çizer.

  • İstemci asla eşya eklemez. Sadece isteyebilir, örneğin "kılıcımı kuşan", ve sunucu bir şey yapmadan önce oyuncunun bir tane olduğunu kontrol eder.
  • Eşyalar sadece senin kontrol ettiğin sunucu kodu üzerinden gelir: yerden alınan eşyalar, sunucunun kontrol ettiği dükkân alışverişleri, ödüller.
  • Tool'ları değil, eşya id'lerini ve miktarları DataStoreService ile oyuncu çıktığında, sunucu kapanırken ve birkaç dakikada bir kaydet. Verileri yüklenmemiş bir oyuncuyu asla kaydetme.
Bu sayfada
  1. Nasıl çalışır
  2. Neden sunucu yönetir
  3. 1. Explorer'ı hazırla
  4. 2. Eşya kataloğu
  5. 3. Sunucuda envanter
  6. 4. Yükle ve kaydet
  7. 5. Yerden alınan eşyalar
  8. 6. Kuşan ve kullan
  9. 7. Izgara UI
  10. Test
  11. Common errors
  12. RoCode ile
  13. Sık sorulan sorular
  14. Kaynaklar ve ek okumalar

Envanter nasıl bir araya gelir

ÇizimB'ye bas, okumak için fareyi bir eşyanın üzerine getir ve tutmak için Sword'a tıkla.

Sistem, her birinin tek bir işi olan altı küçük parçadan oluşuyor. Eşyalarla ilgili tüm kurallar tek bir sunucu modülünde duruyor, yani bir şey bozulduğunda bakılacak tek bir yer var.

Parçalar ve nerede çalıştıkları
ParçaTür ve konumİş
ItemCatalogReplicatedStorage'ta ModuleScriptHer eşyanın ne olduğu: ad, açıklama, en fazla yığın ve kuşanılabilir ya da kullanılabilir olup olmadığı. Sunucu ve tüm istemciler okur.
InventoryServiceServerScriptService'te ModuleScriptHer oyuncunun slotlarını tutar. Eşya ekleyen, çıkaran ve yığan tek kod.
InventoryDataServerScriptService'te ScriptOyuncu girdiğinde eşyalarını yükler ve kaydeder.
InventoryActionsServerScriptService'te ScriptKuşanma ve kullanma isteklerini kontrol edip uygular.
ItemPickupBir Part'ın içinde ScriptOnu alan kişiye bir eşya verir.
InventoryClientStarterPlayerScripts'te LocalScriptIzgarayı çizer ve istek gönderir. Kendi başına hiçbir şeyi değiştirmez.

Veri tek yönde akar. Sunucu bir envanteri değiştirir, sonra o oyuncuya bütün envanterle InventoryUpdated'ı tetikler ve istemci ondan yeniden çizer. Oyuncu bir slota tıkladığında istemci eşyanın id'siyle EquipItem ya da UseItem'ı tetikler; sunucu isteği kontrol eder, değişikliği yapar ve yeni kopya aynı yoldan gelir. Bütün envanteri göndermek değişiklikleri göndermekten daha basit ve birkaç düzine slotla mesaj yine küçük kalıyor.

İstemci neden asla eşya eklemez

Bir eşyayı onu gösteren LocalScript'te eklemek cazip gelir: oyuncu tıklar ve slot dolar. Bu iki şekilde bozulur.

  • Başka kimse görmez. Bir LocalScript'te yapılan değişiklik sadece o oyuncunun cihazında vardır. Sunucu bundan hiç haberdar olmaz, yani kaydedilmez ve hiçbir sunucu scripti onu kullanamaz.
  • Herkes taklit edebilir. Bunu AddItem(itemId, amount) gibi bir RemoteEvent ile düzeltirsen, bir hileci o event'i istediği argümanlarla ve istediği kadar kendisi tetikleyebilir. Roblox'un güvenlik rehberi, sunucunun bir istemcinin gönderdiği her şeyi kullanmadan önce doğrulaması gerektiğini söylüyor.

Bu yüzden bu rehberde istemci sadece oyuncunun zaten sahip olduğu eşyalar hakkında istekte bulunabilir: "bunu kuşan" ve "bunu kullan". Her istek bir eşya id'si taşır, hiçbir miktar taşımaz ve sunucuda bir kontrolden geçer: bir string olmalı, gerçek bir eşya olmalı, oyuncunun en az bir tane olmalı ve saniyede dörtten fazla istek göndermemeli. Sonra sunucu Tool'u katalogda kendisi bulur. İstemciden asla bir Tool, bir yol ya da bir instance kabul etmez; aynı rehber bunu da önermiyor.

Eşyalar sadece sunucu kodundan girer: sunucunun kontrol ettiği yerden alınan bir eşya, sunucunun ücretini aldığı bir satın alma (dükkân rehberi bir tane kuruyor), bir görev ödülü ya da bir drop. Diğer argüman türleri için doğrulamayla birlikte genel RemoteEvent kalıbı için RemoteEvent rehberini oku (ikisi de İngilizce).

Adım 1: Explorer'ı hazırla

Bu nesneleri elle oluştur. Sonraki adımlardaki scriptler onları adlarıyla arıyor, bu yüzden her adı tam göründüğü gibi yaz.

  1. ReplicatedStorage içine InventoryRemotes adında bir Folder ekle. İçine InventoryUpdated, EquipItem ve UseItem adında üç RemoteEvent ekle.
  2. ServerStorage içine ItemTools adında bir Folder ekle. İçine Sword adında bir Tool, Tool'un içine de Handle adında bir Part ekle (1x4x1 stud iyi). Handle'ın Anchored kutusunun işaretsiz olduğundan emin ol: Roblox, karakterlerin anchored parçaları olan bir tool tuttuklarında takılıp kaldıkları konusunda uyarıyor. Adı 2. adımdaki katalogla eşleştiği sürece elindeki bir Tool da olur.
  3. Scriptleri her adıma geldikçe ekle. Ağaç her birinin nereye konduğunu gösteriyor.
Bu rehberi bitirdiğinde Explorer
ReplicatedStorage
  ItemCatalog ModuleScript new
  InventoryRemotes Folder new
    InventoryUpdated RemoteEvent new
    EquipItem RemoteEvent new
    UseItem RemoteEvent new
ServerScriptService
  InventoryService ModuleScript new
  InventoryData Script new
  InventoryActions Script new
ServerStorage
  ItemTools Folder new
    Sword Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    InventoryClient LocalScript new
Workspace
  Apple Part new
    ItemPickup Script new

Adım 2: Eşyalarını bir katalogda listele

Katalog var olabilecek her eşyayı bir kez tanımlar. Envanterler sadece eşyanın id'sini ve bir miktarı tutar. Böylece kayıtlar küçük kalır ve bir eşyanın adını değiştirebilir ya da açıklamasını sonradan baştan yazabilirsin, kimsenin kayıtlı verisine dokunmadan.

ReplicatedStorage'a bir ModuleScript ekle, adını ItemCatalog koy ve içeriğini şununla değiştir:

ModuleScript konum: ReplicatedStorage adı: ItemCatalog
-- Oyunda var olabilecek tüm eşyalar. Sunucu ve tüm istemciler bu listeyi
-- okur; kimin neye sahip olduğuna sadece sunucu karar verir.
export type Item = {
	id: string, -- aşağıdaki anahtarla eşleşmeli
	name: string,
	description: string,
	maxStack: number, -- bu eşyadan bir slota sığabilecek en fazla miktar
	icon: string?, -- isteğe bağlı görsel, "rbxassetid://" ve görselinin ID'si olarak yazılır
	toolName: string?, -- ServerStorage.ItemTools içinde bir Tool: eşya kuşanılabilir
	heal: number?, -- kullanınca geri gelen can: eşya bir tüketilebilir
}

local items: { [string]: Item } = {
	sword = {
		id = "sword",
		name = "Sword",
		description = "Equip it to put it in your hand.",
		maxStack = 1,
		toolName = "Sword",
	},
	apple = {
		id = "apple",
		name = "Apple",
		description = "Use it to restore 25 health.",
		maxStack = 10,
		heal = 25,
	},
	wood = {
		id = "wood",
		name = "Wood",
		description = "A building material.",
		maxStack = 50,
	},
}

local ItemCatalog = {}

-- Bu id'ye sahip eşyayı döndürür, böyle bir eşya yoksa nil
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

İsteğe bağlı alanlar bir eşyanın ne yaptığına karar verir. toolName onu kuşanılabilir, heal kullanılabilir yapar; ikisi de olmayan bir eşya, örneğin odun, başka bir sunucu kodu (crafting, satış) onu çıkarana kadar envanterde kalır.

Bir eşya eklemek için anahtarı ve id'si eşleşen bir girdi ekle. Id'ler büyük küçük harfe duyarlı ve kaydedilen şey onlar, bu yüzden oyuncular eşyaya zaten sahipken bir id'yi asla değiştirme: name'ini değiştir.

Adım 3: Envanterleri sunucuda tut

Bu ModuleScript her oyuncunun envanterinin sahibi. Her envanter bir slot listesi, her slot bir eşya id'si ve bir miktar, artı 20 slotluk bir kapasite. Diğer sunucu scriptleri onun fonksiyonlarını çağırır, tabloyu başka hiçbir şey düzenlemez.

ServerScriptService'e bir ModuleScript ekle ve adını InventoryService koy:

ModuleScript konum: ServerScriptService adı: InventoryService
-- Envanterleri değiştiren tek kod. İstemcilerin göremediği ve çalıştıramadığı
-- ServerScriptService içinde duruyor.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Strict mod WaitForChild üzerinden bir require'ı takip edemez, bu yüzden
-- bu scriptin kullandığı modül kısmını belirtiyoruz
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent

export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }

local CAPACITY = 20 -- oyuncu başına slot
local STARTER_ITEMS: { Slot } = { -- yeni bir oyuncunun neyle başladığı
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

local inventories: { [Player]: Inventory } = {}

local InventoryService = {}

-- Sahibine envanterinin bir kopyasını gönderir. Her değişiklikten sonra çalışır.
local function sync(player: Player)
	local inventory = inventories[player]
	if inventory then
		inventoryUpdated:FireClient(player, {
			capacity = inventory.capacity,
			slots = inventory.slots,
			equipped = inventory.equipped,
		})
	end
end

-- Yığma kuralları: dolu olmayan yığınları doldurur, sonra boş slotlarda yeni yığınlar
-- başlatır. Kaç tane eklendiğini döndürür, istenenden az olabilir.
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
	local remaining = amount
	for _, slot in inventory.slots do
		if remaining == 0 then
			break
		end
		if slot.id == item.id and slot.count < item.maxStack then
			local moved = math.min(item.maxStack - slot.count, remaining)
			slot.count += moved
			remaining -= moved
		end
	end
	while remaining > 0 and #inventory.slots < inventory.capacity do
		local moved = math.min(item.maxStack, remaining)
		table.insert(inventory.slots, { id = item.id, count = moved })
		remaining -= moved
	end
	return amount - remaining
end

function InventoryService.count(player: Player, itemId: string): number
	local inventory = inventories[player]
	local total = 0
	if inventory then
		for _, slot in inventory.slots do
			if slot.id == itemId then
				total += slot.count
			end
		end
	end
	return total
end

-- Bir eşyadan kaç tane daha sığar: yığınlarında kalan boşluk artı boş slotlar
function InventoryService.spaceFor(player: Player, itemId: string): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	if not inventory or not item then
		return 0
	end
	local space = (inventory.capacity - #inventory.slots) * item.maxStack
	for _, slot in inventory.slots do
		if slot.id == itemId then
			space += item.maxStack - slot.count
		end
	end
	return space
end

-- Bir eşyadan en fazla amount kadar ekler. Kaç tane eklendiğini döndürür (eşya yoksa,
-- envanter doluysa ya da henüz yüklenmediyse 0).
function InventoryService.add(player: Player, itemId: string, amount: number): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	local wanted = math.floor(amount)
	if not inventory or not item or wanted < 1 then
		return 0
	end
	local added = addToInventory(inventory, item, wanted)
	if added > 0 then
		sync(player)
	end
	return added
end

-- Bir eşyadan tam olarak amount kadar çıkarır, son yığınlardan başlayarak.
-- Oyuncunun daha azı varsa hiçbir şey çıkarmaz ve false döndürür.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
	local inventory = inventories[player]
	local wanted = math.floor(amount)
	if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
		return false
	end
	local remaining = wanted
	-- Listeyi geriye doğru dolaşır, böylece table.remove hiçbir slotu atlamaz
	for index = #inventory.slots, 1, -1 do
		local slot = inventory.slots[index]
		if slot.id == itemId then
			local taken = math.min(slot.count, remaining)
			slot.count -= taken
			remaining -= taken
			if slot.count == 0 then
				table.remove(inventory.slots, index)
			end
			if remaining == 0 then
				break
			end
		end
	end
	sync(player)
	return true
end

function InventoryService.getEquipped(player: Player): string?
	local inventory = inventories[player]
	return if inventory then inventory.equipped else nil
end

function InventoryService.setEquipped(player: Player, itemId: string?)
	local inventory = inventories[player]
	if inventory then
		inventory.equipped = itemId
		sync(player)
	end
end

-- Bir oyuncunun kayıtlı verileri yüklendiğinde bir kez çağrılır. saved, data store'un
-- döndürdüğü şey: yeni bir oyuncu için nil. Her girdi yığma kurallarından tekrar
-- geçer, bu yüzden silinmiş eşyalar ve eski yığın boyutları hiçbir şeyi bozmaz.
function InventoryService.load(player: Player, saved: any)
	local inventory: Inventory = { slots = {}, capacity = CAPACITY }
	local entries: { Slot } = STARTER_ITEMS
	if type(saved) == "table" and type(saved.slots) == "table" then
		entries = {}
		for _, entry in saved.slots do
			if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
				table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
			end
		end
	end
	for _, entry in entries do
		local item = ItemCatalog.get(entry.id)
		if item and entry.count > 0 then
			addToInventory(inventory, item, entry.count)
		end
	end
	inventories[player] = inventory
	sync(player)
end

-- Kaydetmek için basit bir kopya, ya da bu oyuncunun verileri hiç yüklenmediyse nil
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
	local inventory = inventories[player]
	if not inventory then
		return nil
	end
	local slots: { Slot } = {}
	for index, slot in inventory.slots do
		slots[index] = { id = slot.id, count = slot.count }
	end
	return { version = 1, slots = slots }
end

function InventoryService.unload(player: Player)
	inventories[player] = nil
end

return InventoryService

type satırları ve require'dan sonraki :: dönüşümü sadece Luau'nun tür denetleyicisine yardım eder; o, WaitForChild ile bulunan bir modülün ne döndürdüğünü göremez. Oyun çalışırken hiçbir şeyi değiştirmezler. Bu rehberdeki diğer scriptler de aynısını yapıyor.

Yukarıdaki katalogla, elmaların 10'a kadar yığıldığı durumda yığma kuralları şöyle çalışır:

  • 7'lik bir yığını olan bir oyuncuya 15 elma eklersen o yığın 10'a kadar dolar, sonra 5'lik yeni bir yığın başlar.
  • Slotlar bittiğinde add sığanı ekler ve o sayıyı döndürür. Ya hep ya hiç olması gerektiğinde, 5. adımdaki yerden alınan eşyanın yaptığı gibi, önce spaceFor'u çağır.
  • remove ya hep ya hiç. 2 elması olan bir oyuncudan 3 elma istemek hiçbirini çıkarmaz ve false döndürür, bu yüzden karşılığında bir şey vermeden önce sonucu kontrol et.
  • Slotlarda boşluk olmaz: biri boşaldığında diğerleri yukarı kayar. Böylece listeyi göndermek ve kaydetmek kolay. Sondaki sorular, konumunu koruyan slotların nasıl yapılacağını anlatıyor.
Diğer sunucu scriptlerinin çağırabildikleri
FonksiyonDöndürürNe için kullanılır
add(player, itemId, amount)Kaç tane eklendiğiYerden alınan eşyalar, ödüller, satın almalar
remove(player, itemId, amount)Hepsi çıkarıldıysa trueKullanmak, satmak, craft etmek
count(player, itemId)Tüm yığınlardaki toplamBir oyuncunun neye sahip olduğunu kontrol etmek
spaceFor(player, itemId)Kaç tane daha sığacağıYa hep ya hiç eklemeden önce kontrol etmek
getEquipped, setEquippedKuşanılan eşyanın id'si ya da nilKuşanmak, 6. adımda
load, serialize, unloadKaydetmeye hazır bir kopya (serialize)Yüklemek ve kaydetmek, 4. adımda

Adım 4: Her envanteri yükle ve kaydet

Envanterler sunucunun belleğinde duruyor, yani oyuncu çıktığında kaybolurlar. Bu script oyuncu girdiğinde slotlarını bir data store'dan yükler ve oyuncu çıktığında, sunucu kapanırken ve sunucu çökerse diye her üç dakikada bir geri yazar. Sadece eşya id'lerini ve miktarları kaydeder: data store'lar Tool gibi Instance'ları saklayamaz.

ServerScriptService'e bir Script ekle ve adını InventoryData koy:

Script konum: ServerScriptService adı: InventoryData
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	load: (player: Player, saved: any) -> (),
	serialize: (player: Player) -> any,
	unload: (player: Player) -> (),
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local STORE_NAME = "PlayerInventory_v1"
local LOAD_ATTEMPTS = 3
local AUTOSAVE_SECONDS = 180

-- Sadece kayıtlı verileri yüklenen oyuncular kaydedilir. Başarısız bir yüklemeden sonra
-- asla kayıt olmamalı, yoksa boş envanter gerçeğinin yerine geçer.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

local function keyFor(player: Player): string
	return "User_" .. player.UserId
end

-- Başarısız bir istek kimseye eşyalarını kaybettirmemeli, bu yüzden birkaç kez tekrar dener.
-- GetDataStore da pcall'un içinde, böylece data store kullanamayan bir Studio
-- oturumu bu scripti durdurmak yerine bir uyarı alır.
local function loadSaved(player: Player): (boolean, any)
	for attempt = 1, LOAD_ATTEMPTS do
		local ok, result = pcall(function()
			return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
		end)
		if ok then
			return true, result
		end
		warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
		if attempt < LOAD_ATTEMPTS then
			task.wait(attempt * 2)
		end
	end
	return false, nil
end

local function onPlayerAdded(player: Player)
	local ok, saved = loadSaved(player)
	if player.Parent ~= Players then
		return -- biz yüklerken çıktı
	end
	if ok then
		InventoryService.load(player, saved) -- yeni bir oyuncu için saved nil
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Genelde Studio'nun API servislerine erişiminin kapalı olduğu anlamına gelir. Test edebilmek için
		-- başlangıç eşyalarıyla oyna, ama onları asla kaydetme.
		warn("Inventory not loaded: playing with starter items that will not be saved")
		InventoryService.load(player, nil)
	else
		player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
	end
end

local function save(player: Player)
	if not canSave[player] then
		return -- verileri hiç yüklenmedi, yani yazılacak güvenli bir şey yok
	end
	local data = InventoryService.serialize(player)
	if not data then
		return
	end
	activeSaves += 1
	local ok, err = pcall(function()
		DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
	end)
	activeSaves -= 1
	if not ok then
		warn(`Inventory save failed for {player.Name}: {err}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	save(player)
	canSave[player] = nil
	InventoryService.unload(player)
end)

-- Sunucu kapanırken hâlâ burada olan herkesi kaydeder, sonra PlayerRemoving'in
-- başlattıkları dahil süren her kaydı bekler
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Herkesi birkaç dakikada bir kaydeder, böylece bir sunucu çökmesi bir oturuma değil, dakikalara mal olur
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Script ne yapıyor ve neden:

  • Varsayılanlarla yükler. Yeni bir oyuncunun kaydı yoktur, bu yüzden GetAsync nil döndürür ve oyuncu başlangıç eşyalarını alır. Kayıtlı slotlar yığma kurallarından tekrar geçer, yani katalogdan çıkardığın bir eşya ya da daha küçük bir en fazla yığın bir yüklemeyi bozamaz. Artık sığmayan ya da id'si artık katalogda olmayan şey atılır ve bir sonraki kayıt bunu kalıcı yapar, bu yüzden oyuncuların sahip olabileceği tüm id'leri katalogda tut.
  • Başarısız bir yüklemeden sonra asla kaydetme. Sadece canSave içindeki oyuncular yazılır. Canlı bir sunucuda verileri üç denemeden sonra hâlâ yüklenmeyen bir oyuncudan tekrar girmesi istenir. Studio'da kaydedilmeyen başlangıç eşyaları alır, tekrar denemeler yüzünden birkaç saniye gecikmeyle; place API erişimi açık olarak yayımlanana kadar göreceğin şey bu.
  • Çıkışta ve kapanışta kaydeder. BindToClose hâlâ sunucuda olan herkesi kaydeder ve zaten süren kayıtları bekler. Roblox bağlanan fonksiyonlara en fazla 30 saniye veriyor.
  • Limitlerin içinde kal. Oyuncu başına her üç dakikada bir yazma, artı çıkışta bir tane, sunucu başına dakikada 60 yazma artı her oyuncu için 40 olan varsayılan bütçenin çok altında kalıyor (30 Eylül 2026 tarihli dokümantasyona göre). User_ anahtar kalıbı Roblox'un en iyi uygulamalarını izliyor ve user ID'yi SetAsync'e vermek verileri o oyuncuya bağlıyor; Roblox bunu veri silme taleplerini karşılamak için şiddetle öneriyor.

Küçük bir oyun için bu iyi bir temel. Sunucular arasında çok hızlı geçen bir oyuncunun, önceki sunucu verilerini kaydetmeden önce onları yüklemesini engelleyen oturum kilidi ve SetAsync yerine UpdateAsync'in ne zaman kullanılacağı DataStore eğitiminde (İngilizce) anlatılıyor.

Adım 5: Dünyadan eşya ver

Yerden alınan bir eşya, eşyaların bir envantere girmesinin en basit yolu: bir oyuncu onu kullandığında bir eşya ekleyen, ProximityPrompt'u olan bir parça. Script onun Triggered event'ini sunucuda dinler, yani eşya istemcinin karışamayacağı yerde eklenir.

  1. Workspace'e bir Part ekle, adını Apple koy ve kırmızıya boya. Görünmezken kimse ona çarpmasın diye Anchored'ı işaretle ve CanCollide'ın işaretini kaldır. Prompt parçanın adını gösterir.
  2. Parça seçiliyken Properties penceresinin Attributes bölümüne in ve +'ya tıkla. string türünde ItemId ekle ve Save'e tıkla, sonra değerini apple yap. Aynı şekilde Amount'u number olarak 1 değeriyle ekle.
  3. Parçanın içine bir Script ekle, adını ItemPickup koy ve bu kodu yapıştır:
Script konum: Workspace'teki Apple Part'ı adı: ItemPickup
-- Bu Script'i bir Part'ın içine koy ve Part'a iki attribute ver:
-- ItemId (apple gibi bir string) ve Amount (1 gibi bir number).
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	add: (player: Player, itemId: string, amount: number) -> number,
	spaceFor: (player: Player, itemId: string) -> number,
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local part = script.Parent :: BasePart
local RESPAWN_SECONDS = 15

local itemId = part:GetAttribute("ItemId")
local amount = part:GetAttribute("Amount")
if typeof(itemId) ~= "string" or typeof(amount) ~= "number" or amount < 1 then
	error(`{part:GetFullName()} needs an ItemId (string) and an Amount (number, 1 or more) attribute`)
end

local prompt = Instance.new("ProximityPrompt")
prompt.ActionText = "Pick up"
prompt.ObjectText = part.Name
prompt.Parent = part

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- başka biri az önce aldı
	end
	-- İsteğe güvenmek yerine mesafeyi sunucuda kontrol et
	local character = player.Character
	if not character then
		return
	end
	local distance = (character:GetPivot().Position - part.Position).Magnitude
	if distance > prompt.MaxActivationDistance + 5 then
		return
	end
	if InventoryService.spaceFor(player, itemId) < amount then
		return -- yeterli yer yok: eşyayı olduğu yerde bırak
	end
	InventoryService.add(player, itemId, amount)

	prompt.Enabled = false
	part.Transparency = 1
	task.wait(RESPAWN_SECONDS)
	part.Transparency = visibleTransparency
	prompt.Enabled = true
end)

Daha fazla yerden alınan eşya koymak için parçayı kopyala. Odun, başka bir kılıç ya da bir yığın elma vermek için attribute'ları değiştir.

Roblox Triggered için mesafeyi kontrol ediyor, ama güvenlik rehberi yine de prompt'ları sunucuda doğrulamanı söylüyor: bir hileci bir prompt'un event'lerini Enabled false iken bile tetikleyebilir ve anchored olmayan bir parçayı karakterine yaklaştırabilir. Bu yüzden script Enabled'ı ve mesafeyi kendisi kontrol ediyor ve bu yüzden parça anchored.

Diğer her sunucu scripti eşyaları aynı şekilde verir. Bir satın almadan, bir görevden ya da bir öldürmeden sonra yukarıdaki scriptler gibi InventoryService'i require et ve InventoryService.add(player, "wood", 5)'i çağır. Eşyanın kaybolmaması gereken her durumda önce spaceFor'u kontrol et. Bir NPC de bir kaynak olabilir: NPC diyalog rehberinde (İngilizce) bir cevap sunucuda bir eylem çalıştırıyor ve o eylem InventoryService.add'i aynı şekilde çağırabilir.

Adım 6: Tool kuşan ve eşya kullan

Bir istemcinin yapabileceği tek istekleri iki RemoteEvent taşıyor. EquipItem, eşyanın Tool'unun ServerStorage'taki bir kopyasını oyuncunun Backpack'ine (ekranın altındaki hotbar) ve eline koyar; tekrar istemek onu geri alır. UseItem, kullanılabilir bir eşyadan bir tane çıkarır ve etkisini uygular; burada etki iyileştirmek.

ServerScriptService'e bir Script ekle ve adını InventoryActions koy:

Script konum: ServerScriptService adı: InventoryActions
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ServerStorage = game:GetService("ServerStorage")

type Item = { id: string, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type InventoryApi = {
	count: (player: Player, itemId: string) -> number,
	remove: (player: Player, itemId: string, amount: number) -> boolean,
	getEquipped: (player: Player) -> string?,
	setEquipped: (player: Player, itemId: string?) -> (),
}
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local itemTools = ServerStorage:WaitForChild("ItemTools")

local COOLDOWN_SECONDS = 0.25
local lastRequest: { [Player]: number } = {}

-- Tüm istekler burada başlar. Bir istemci her an her şeyi gönderebilir, bu yüzden
-- türü, eşyanın var olduğunu, oyuncunun bir tane olduğunu ve hızı kontrol et.
local function ownedItem(player: Player, itemId: unknown): Item?
	if typeof(itemId) ~= "string" then
		return nil
	end
	local now = os.clock()
	if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
		return nil
	end
	lastRequest[player] = now
	local item = ItemCatalog.get(itemId)
	if not item or InventoryService.count(player, itemId) < 1 then
		return nil
	end
	return item
end

-- Kopya nerede olursa olsun bu eşyanın Tool'unu yok eder: hotbar, el ya da StarterGear
local function destroyTools(container: Instance?, itemId: string)
	if not container then
		return
	end
	for _, child in container:GetChildren() do
		if child:IsA("Tool") and child:GetAttribute("InventoryItem") == itemId then
			child:Destroy()
		end
	end
end

local function unequip(player: Player)
	local equippedId = InventoryService.getEquipped(player)
	if equippedId then
		destroyTools(player:FindFirstChildOfClass("Backpack"), equippedId)
		destroyTools(player.Character, equippedId)
		destroyTools(player:FindFirstChildOfClass("StarterGear"), equippedId)
		InventoryService.setEquipped(player, nil)
	end
end

local function equip(player: Player, item: Item, toolName: string)
	local template = itemTools:FindFirstChild(toolName)
	local backpack = player:FindFirstChildOfClass("Backpack")
	if not template or not template:IsA("Tool") or not backpack then
		warn(`Cannot equip {item.id}: no Tool named {toolName} in ServerStorage.ItemTools`)
		return
	end
	unequip(player) -- aynı anda tek bir tool kuşanılır

	local tool = template:Clone()
	tool.CanBeDropped = false -- başka biri düşürülen bir kopyayı alabilir
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- StarterGear'daki ikinci bir kopya yeniden doğduktan sonra tekrar Backpack'e kopyalanır
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		local gearCopy = tool:Clone()
		gearCopy.Parent = starterGear
	end

	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		humanoid:EquipTool(tool) -- doğrudan eline koyar
	end
	InventoryService.setEquipped(player, item.id)
end

equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.toolName then
		return
	end
	if InventoryService.getEquipped(player) == item.id then
		unequip(player) -- kuşanılan eşyaya tekrar tıklamak onu kaldırır
	else
		equip(player, item, item.toolName)
	end
end)

useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.heal then
		return
	end
	local heal = item.heal
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return -- ölü ya da canı dolu: eşyayı boşa harcama
	end
	-- Önce eşyayı çıkar, sadece bu işe yaradıysa iyileştir
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
Her isteğin ne yapabildiği
İstekİstemci gönderirSunucu harekete geçmeden önce kontrol eder
EquipItemBir eşya id'siBir string olduğunu, eşyanın var olduğunu, oyuncunun bir tane olduğunu, isteklerin saniyede dörtten hızlı gelmediğini, eşyanın bir toolName'i olduğunu ve ServerStorage.ItemTools içinde o adda bir Tool olduğunu
UseItemBir eşya id'siAynı tür, sahiplik ve hız kontrollerini, eşyanın bir heal değeri olduğunu, karakterin hayatta ve yaralı olduğunu ve can vermeden önce bir eşyanın çıkarıldığını

Üç ayrıntı bir Tool'un kopyalanmasını ya da kaybolmasını önlüyor. Kopyanın CanBeDropped'ı false, çünkü düşürülen bir Tool Workspace'e düşer ve orijinali hâlâ envanterdeyken başka bir oyuncu onu kapabilir. Her kopya bir InventoryItem attribute'u taşır, bu yüzden kuşanma kaldırılırken tüm kopyalar nerede olurlarsa olsunlar bulunup yok edilebilir. Oyuncunun bir StarterGear konteyneri olduğunda da içine ikinci bir kopya konur. Roblox, karakter her doğduğunda StarterGear'ı Backpack'e kopyalar, yani kuşanılmış bir kılıç yeniden doğduktan sonra geri gelir.

Aynı anda sadece bir Tool kuşanılır ve kuşanılan şey kaydedilmez, bu yüzden tekrar giren bir oyuncu boş bir hotbar'la başlar. Sonradan eşya satmak ya da düşürmek eklersen, bir eşyanın son kopyası envanterden çıkmadan önce kuşanmasını kaldır.

Örnekteki Sword gerçekten dövüşen bir kılıca dönüşebilir: kılıç rehberindeki Tool'u kur, adını Sword olarak bırak ve örnektekinin yerine ItemTools'a koy. O rehberin sunucu scripti, oyuncu kılıcı nasıl elde etmiş olursa olsun her vuruşu kontrol eder.

Adım 7: Envanter ızgarasını çiz

LocalScript bütün pencereyi kodla kuruyor, yani elle hiçbir UI kurmana gerek yok. Bir ScrollingFrame slotları tutar, içindeki bir UIGridLayout onları satırlara dizer ve AutomaticCanvasSize satırlar eklendikçe kaydırma alanını büyütür.

Explorer'da StarterPlayer'ı aç, StarterPlayerScripts içine bir LocalScript ekle ve adını InventoryClient koy:

LocalScript konum: StarterPlayerScripts adı: InventoryClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

type Item = { name: string, description: string, icon: string?, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type Slot = { id: string, count: number }
type Snapshot = { capacity: number, slots: { Slot }, equipped: string? }

local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent

local player = Players.LocalPlayer
local TOGGLE_KEY = Enum.KeyCode.B

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	slot = Color3.fromRGB(44, 38, 64),
	empty = Color3.fromRGB(34, 30, 48),
	equipped = Color3.fromRGB(124, 77, 255),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
}

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function makeLabel(parent: GuiObject, text: string, textSize: number): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Font = Enum.Font.BuilderSansBold
	label.TextColor3 = COLOURS.text
	label.TextSize = textSize
	label.Text = text
	label.Parent = parent
	return label
end

-- 1. Pencereyi bir kez kurar. ResetOnSpawn = false onu yeniden doğuşta korur.
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local openButton = Instance.new("TextButton")
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(140, 40)
openButton.BackgroundColor3 = COLOURS.panel
openButton.Font = Enum.Font.BuilderSansBold
openButton.TextColor3 = COLOURS.text
openButton.TextSize = 18
openButton.Text = "Inventory (B)"
addCorner(openButton, 8)
openButton.Parent = gui

local panel = Instance.new("Frame")
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.9, 0.8)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
addCorner(panel, 12)
panel.Parent = gui

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(440, 400)
sizeLimit.Parent = panel

local title = makeLabel(panel, "Inventory", 22)
title.Position = UDim2.fromOffset(16, 8)
title.Size = UDim2.new(1, -32, 0, 32)
title.TextXAlignment = Enum.TextXAlignment.Left

local slotCount = makeLabel(panel, "", 16)
slotCount.Position = UDim2.fromOffset(16, 8)
slotCount.Size = UDim2.new(1, -32, 0, 32)
slotCount.TextColor3 = COLOURS.muted
slotCount.TextXAlignment = Enum.TextXAlignment.Right

local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize hücreler sığsın diye onu büyütür
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel

local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.fromOffset(72, 72)
layout.CellPadding = UDim2.fromOffset(8, 8)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = grid

local info = makeLabel(panel, "Click an item to equip or use it.", 16)
info.AnchorPoint = Vector2.new(0, 1)
info.Position = UDim2.new(0, 16, 1, -8)
info.Size = UDim2.new(1, -32, 0, 40)
info.Font = Enum.Font.BuilderSans
info.TextColor3 = COLOURS.muted
info.TextWrapped = true
info.TextXAlignment = Enum.TextXAlignment.Left

-- 2. Slot başına bir hücre. Bu sadece sunucunun gönderdiğini çizer; envanteri
-- asla kendi başına değiştirmez.
local function makeCell(index: number, slot: Slot?, equippedId: string?)
	local cell = Instance.new("TextButton")
	cell.LayoutOrder = index
	cell.Text = ""
	cell.AutoButtonColor = slot ~= nil
	cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
	addCorner(cell, 8)
	cell.Parent = grid
	if not slot then
		return -- boş bir slot
	end

	local itemId = slot.id
	local item = ItemCatalog.get(itemId)
	local name = if item then item.name else itemId

	if item and item.icon then
		local image = Instance.new("ImageLabel")
		image.BackgroundTransparency = 1
		image.Size = UDim2.fromScale(1, 1)
		image.Image = item.icon
		image.Parent = cell
	else
		local nameLabel = makeLabel(cell, name, 14)
		nameLabel.Size = UDim2.fromScale(1, 1)
		nameLabel.TextWrapped = true
	end

	if slot.count > 1 then
		local countLabel = makeLabel(cell, `x{slot.count}`, 14)
		countLabel.AnchorPoint = Vector2.new(1, 1)
		countLabel.Position = UDim2.new(1, -6, 1, -4)
		countLabel.Size = UDim2.fromOffset(40, 16)
		countLabel.TextXAlignment = Enum.TextXAlignment.Right
	end

	if itemId == equippedId then
		local outline = Instance.new("UIStroke")
		outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
		outline.Color = COLOURS.equipped
		outline.Thickness = 3
		outline.Parent = cell
	end

	cell.MouseEnter:Connect(function()
		info.Text = if item then `{item.name}: {item.description}` else name
	end)
	cell.Activated:Connect(function()
		-- İste, asla emretme: sunucu isteği kontrol eder ve sonucu geri gönderir
		if item and item.toolName then
			equipItem:FireServer(itemId)
		elseif item and item.heal then
			useItem:FireServer(itemId)
		end
	end)
end

local function render(snapshot: Snapshot)
	for _, child in grid:GetChildren() do
		if child:IsA("GuiButton") then
			child:Destroy()
		end
	end
	for index = 1, snapshot.capacity do
		makeCell(index, snapshot.slots[index], snapshot.equipped)
	end
	slotCount.Text = `{#snapshot.slots} / {snapshot.capacity} slots`
end

-- Sunucu bunu yüklemeden sonra ve her değişiklikten sonra tetikler
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Butonla ya da B tuşuyla açılıp kapanır
local function toggle()
	panel.Visible = not panel.Visible
end

openButton.Activated:Connect(toggle)
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessedEvent: boolean)
	if not gameProcessedEvent and input.KeyCode == TOGGLE_KEY then
		toggle()
	end
end)

StarterPlayerScripts'teki bir LocalScript oturum başına bir kez çalışır ve ResetOnSpawn = false karakter yeniden doğduğunda ScreenGui'yi korur, yani ızgara sunucunun gönderdiği son kopyayı göstermeye devam eder.

İstemci boşlar dahil her slot için bir hücre çizer, yani 20 slotluk bir envanter her zaman 20 slot olarak görünür. Her güncelleme eski hücreleri yok edip yenilerini kurar; bu basit ve birkaç düzine slotla iyi çalışıyor. Sunucu bu script bağlanmadan önce InventoryUpdated'ı tetiklerse Roblox mesajı kuyruğa alır ve handler bağlandığında teslim eder, yani ilk envanter kaybolmaz.

Pencereyi Studio'da tasarlamayı mı tercih edersin? Şablon bir slotu olan bir ScreenGui kur ve makeCell içinde onu Clone et. İkonlar için katalogdaki bir eşyanın icon'una yüklediğin bir görseli koy, hücresi adın yerine görseli gösterir.

Envanteri test et

  1. Play'e bas. Envanteri soldaki butonla ya da B ile aç: yeni bir oyuncunun bir Sword'u ve 3 Apple'ı var ve sayaç 2 / 20 slots diyor. Studio data store kullanabilene kadar eşyalar Output'taki yükleme uyarılarından sonra birkaç saniye gecikmeyle çıkar ve kaydedilmez.
  2. Sword'a tıkla. Elinde ve hotbar'da belirir, slotu mor bir çerçeve alır. Kaldırmak için tekrar tıkla.
  3. Apple parçasına yürü ve prompt'unu kullan. Elma yığını 4'e çıkar ve parça 15 saniye boyunca kaybolur.
  4. İyileştirmeyi test etmek için önce canını düşür. Client/Server anahtarını Server'a çevir, Explorer'da karakterinin Humanoid'ini seç, Health'i 50 yap, Client'a geri dön ve bir Apple'a tıkla.
  5. Studio'nun API servislerine erişimi açıkken oyunu durdur ve tekrar oyna. Aldığın elma hâlâ orada. Bir yükleme ya da kayıt başarısız olduysa Output bunu söyler.

Birden fazla oyuncuyla görmek için test seçeneklerinde 2 istemciyle Server & Clients'ı seç. Her oyuncu sadece kendi envanterini görür, ama ikisi de diğerinin elindeki kılıcı görebilir.

Sık yapılan hatalar ve çözümleri

Çoğu sorun Output penceresinde bir uyarı ya da kırmızı bir hata satırı olarak görünür. İlkini oku: sonraki hatalar genelde onun sonucudur.

Bir WaitForChild çağrısında Infinite yield possible

Bir script, tam o adla var olmayan bir nesneyi bekliyor. Explorer'ını 1. adımdaki ağaçla karşılaştır: ReplicatedStorage'ta üç RemoteEvent'iyle InventoryRemotes, ServerStorage'ta ItemTools ve iki modül. Adlar büyük küçük harfe duyarlı. Script hataları rehberi (İngilizce) bu uyarıyı daha ayrıntılı anlatıyor.

Izgara açılıyor ama boş kalıyor

İstemci sadece sunucunun gönderdiğini çizer. Output'ta Inventory load failed uyarılarını ara ve InventoryData'nın ServerScriptService'te, yanında InventoryService ModuleScript'i ile, LocalScript değil Script olduğunu kontrol et. Output bir Remote event invocation hatası gösteriyorsa istemcide InventoryUpdated'ı dinleyen hiçbir şey yok: InventoryClient'tan gelen daha önceki bir hatayı ara.

Studio'da her oynadığımda eşyalar sıfırlanıyor

Output Inventory not loaded: playing with starter items that will not be saved diyorsa place yayımlanmamış ya da Studio'nun API servislerine erişimi kapalı. 4. adımda anlatıldığı gibi, oyununun bir test kopyasında aç.

Kılıca tıklamak hiçbir şey yapmıyor

Output'ta Cannot equip sword'u ara: ServerStorage.ItemTools içindeki Tool'un adı katalogdaki toolName ile tamamen aynı olmalı. Bir Tool'un tutulabilmesi için ayrıca Handle adında bir parçaya ihtiyacı var, RequiresHandle'ını false yapmadıysan.

Alma prompt'u çıkıyor ama hiçbir şey eklenmiyor

ItemId attribute'u büyük küçük harf dahil katalogdaki bir id ile tam eşleşmeli: Apple değil, apple. Oyuncunun envanteri hâlâ yüklenirken ya da miktarın tamamına yer yokken hiçbir şey eklenmez.

Kaydedilen şeyi değiştirdikten sonra kayıt başarısız oluyor

Data store'lar basit verileri kabul eder: string'ler, sayılar, boolean'lar ve bunlardan oluşan tablolar. Bir Tool'u, bir Part'ı ya da başka herhangi bir Instance'ı kaydetmek başarısız olur ya da değer nil olarak kaydedilir. Eşyanın id'sini ve miktarını kaydet, geri kalan her şeyi serialize'ın yaptığı gibi katalogdan yeniden kur.

RoCode ile kur

Sistemi elle kurmak yerine anlatmayı tercih ediyorsan RoCode onu açık olan place'inde kurabilir. Roblox Studio için bir yapay zeka ajanı: özelliği bir web sohbetinde anlatıyorsun ve Studio plugin'i, sana yapıştıracağın kod vermek yerine scriptleri ve nesneleri Explorer'ında oluşturuyor.

Sen yazarsın

Eşyaları yığan 20 slotluk bir envanter, B ile açılan bir ızgara UI, ServerStorage'ta oyuncuların kuşanabileceği bir kılıç, iyileştiren elmalar ve DataStoreService ile kayıt ekle.

RoCode yapar
  • Bir adım gerektirdiğinde Search Game ve Search Scripts ile place'ini inceleyebilir, böylece ikinci bir sistem eklemek yerine zaten var olan nesnelerin, remote'ların ya da kayıt kodunun üzerine kurar
  • Klasörleri ve RemoteEvent'leri Create Instance ile, ModuleScript'leri, Script'leri ve LocalScript'i Create Script ile oluşturur
  • Pencereyi, örnek slotları olan bir envanter düzeni içeren Build UI ile kurabilir; slotları sunucudan dolduran kod ayrı scriptlerde yazılır
  • Her scriptin Studio'nun içinde derlendiğini Check Script ile kontrol eder; bu, derleme hatalarını ve bazı riskli kalıpları yakalar ama tür denetimi ya da lint yapmaz ve kodunu çalıştırmaz

Her değişiklik grubu Studio'da bir geri alma noktası. RoCode, Studio'nun API servislerine erişimini açamaz, bunu sen yaparsın. Plugin 3.9 ya da daha yenisiyle kısa bir oyun testi çalıştırıp hataları okuyabilir, plugin 3.9.15 ya da daha yenisiyle de test karakteri tuşlara basıp eşya kuşanabilir, ama sadece test etmeye karar verdiği şeyi kontrol eder, bu yüzden kaydı bir oyun testiyle kendin dene. Bir envanter kayıt ve tool'lar gibi başka sistemlerin üzerine oturur ve kendi Studio place'inde kuran bir yapay zeka oyun yapıcısı onları prompt prompt ekler. RoCode Studio'ya nasıl bağlanır.

Sık sorulan sorular

Roblox'un Backpack'ini mi kullanayım yoksa kendi envanterimi mi yapayım?

Backpack, Roblox'un yerleşik envanteri: içindeki her Tool hotbar'da bir buton olarak görünür. Oyunundaki tüm eşyalar Tool ise ve yığınlara, miktarlara ya da slot sınırına ihtiyacın yoksa yetebilir, ama yine de her oyuncunun hangi Tool'lara sahip olduğunu kaydetmen gerekir. Kendi envanterin malzemeler ve tüketilebilirler gibi Tool olmayan eşyalar için. Bu rehber ikisini de kullanıyor: envanter her şeyi tutar, Backpack de kuşanılan Tool'u tutar.

Roblox'un varsayılan hotbar'ını nasıl gizlerim?

Bir LocalScript'ten StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)'ı çağır. Hotbar gizliyken oyuncuların kuşanılmış bir Tool'u tutmak ve kaldırmak için başka bir yola ihtiyacı olur, örneğin sunucudan Humanoid:EquipTool ya da Humanoid:UnequipTools'u çağırmasını isteyen bir buton.

Sürükle bırak için slotların konumlarını korumasını nasıl sağlarım?

Slot başına bir girdisi olan sabit uzunlukta bir liste tut ve boş slotları nil yerine boş bir id gibi bir değerle işaretle, çünkü Roblox bir RemoteEvent ile gönderilen tablolarda nil değerlerini önermiyor. Sonra iki slot numarası gönderen bir MoveItem RemoteEvent'i ekle ve sunucunun yer değiştirmeden önce ikisinin de 1 ile kapasite arasında tam sayılar olduğunu kontrol etmesini sağla.

Kaydedilmiş bir envanter ne kadar yer kaplayabilir?

Bir data store değeri serileştirildikten sonra en fazla 4,194,304 karakter olabilir (30 Eylül 2026 tarihli dokümantasyona göre). Bir id ve miktar listesi bunun minicik bir kısmını kullanır. Bir kaydı büyüten şey eşya başına metin, örneğin her eşya için kaydedilen özel adlar ya da uzun açıklamalar.

Eşyaları coin karşılığında nasıl alıp satarım?

Her şeyi sunucuda yap. Satmak için InventoryService.remove'u çağır ve sadece true döndürdüyse öde. Almak için fiyatı ve spaceFor'u kontrol et, coin'leri düş, sonra add'i çağır. Dükkân rehberi (İngilizce) satın alma kısmını kuruyor.

Kaynaklar ve ek okumalar

Kod nasıl kontrol edildi: bu sayfadaki her script, Roblox API tanımlarıyla Luau'nun katı tür denetleyicisinden geçiyor (luau-lsp, 20 Kasım 2026). Tür denetimi yanlış yazılmış API'leri ve hatalı türleri yakalar, oyun mantığını değil. Bu yüzden yayınlamadan önce Studio'da test et.

RoCode'u kendi oyununda dene.

Her gün ücretsiz kredi, kart gerekmez. Plugin'i kur, özelliği anlat ve Studio'da ne oluştuğunu kontrol et.