Tutorial · Spielsysteme

Ein Inventar-System in Roblox Studio erstellen

Ein Inventar sieht nach einer UI-Aufgabe aus, aber ob sich deins ausnutzen lässt oder Items verliert, hängt davon ab, wo die Items liegen. Dieser Guide hält die Items jedes Spielers in einer Tabelle auf dem Server, schickt jedem Spieler eine Kopie, die als Grid gezeichnet wird, lässt ihn Tools ausrüsten und Verbrauchsgegenstände benutzen, über Anfragen, die der Server prüft, und speichert alles mit einem Data Store.

Aktualisiert am 14. November 202616 Min. LesezeitGeschrieben von

Kurz gesagt

Halte die Items jedes Spielers in einer Tabelle auf dem Server, in einem ModuleScript in ServerScriptService, das als einziger Code Items hinzufügen, entfernen oder stapeln darf. Liste deine Items einmal in einem ModuleScript in ReplicatedStorage auf (ID, Name, maximale Stapelgröße). Nach jeder Änderung feuert der Server ein RemoteEvent an diesen Spieler mit einer Kopie seines Inventars, und ein LocalScript zeichnet es als Grid mit einem ScrollingFrame und einem UIGridLayout.

  • Der Client fügt nie Items hinzu. Er kann nur fragen, zum Beispiel "rüste mein Schwert aus", und der Server prüft, ob der Spieler eins besitzt, bevor er handelt.
  • Items kommen nur über Server-Code, den du kontrollierst: Pickups, Shop-Käufe, die der Server geprüft hat, Belohnungen.
  • Speichere Item-IDs und Anzahlen, keine Tools, mit DataStoreService, wenn Spieler gehen, wenn der Server herunterfährt und alle paar Minuten. Speichere nie einen Spieler, dessen Daten nicht geladen werden konnten.
Auf dieser Seite
  1. Wie es zusammenhängt
  2. Warum der Server die Items hat
  3. 1. Explorer einrichten
  4. 2. Item-Katalog
  5. 3. Server-Inventar
  6. 4. Laden und speichern
  7. 5. Item-Pickups
  8. 6. Ausrüsten und benutzen
  9. 7. Grid-UI
  10. Testen
  11. Häufige Fehler
  12. Mit RoCode
  13. Häufige Fragen
  14. Quellen und weiterführende Links

Wie das Inventar zusammenhängt

IllustrationDrück B, fahr über ein Item, um es zu lesen, und klick auf das Sword, um es zu halten.

Das System besteht aus sechs kleinen Teilen mit je einer Aufgabe. Jede Regel über Items steht in einem einzigen Modul auf dem Server, also gibt es genau eine Stelle, an der du suchen musst, wenn etwas schiefgeht.

Die Teile und wo sie laufen
TeilTyp und OrtAufgabe
ItemCatalogModuleScript in ReplicatedStorageWas jedes Item ist: Name, Beschreibung, maximale Stapelgröße und ob es sich ausrüsten oder benutzen lässt. Der Server und jeder Client lesen es.
InventoryServiceModuleScript in ServerScriptServiceHält die Slots jedes Spielers. Der einzige Code, der Items hinzufügt, entfernt und stapelt.
InventoryDataScript in ServerScriptServiceLädt die Items eines Spielers, wenn er beitritt, und speichert sie.
InventoryActionsScript in ServerScriptServicePrüft Anfragen zum Ausrüsten und Benutzen und führt sie aus.
ItemPickupScript in einem PartGibt jedem, der das Pickup einsammelt, ein Item.
InventoryClientLocalScript in StarterPlayerScriptsZeichnet das Grid und schickt Anfragen. Es ändert selbst nichts.

Die Daten fließen in eine Richtung. Der Server ändert ein Inventar, feuert dann InventoryUpdated mit dem ganzen Inventar an diesen Spieler, und der Client zeichnet es daraus neu. Klickt der Spieler auf einen Slot, feuert der Client EquipItem oder UseItem mit der ID des Items; der Server prüft die Anfrage, macht die Änderung, und die neue Kopie kommt auf demselben Weg an. Das ganze Inventar zu schicken ist einfacher, als Änderungen zu schicken, und bei ein paar Dutzend Slots bleibt die Nachricht klein.

Warum der Client nie Items hinzufügt

Es ist verlockend, ein Item in dem LocalScript hinzuzufügen, das es anzeigt: Der Spieler klickt, der Slot füllt sich. Das geht auf zwei Arten schief.

  • Niemand sonst sieht es. Eine Änderung in einem LocalScript existiert nur auf dem Gerät dieses Spielers. Der Server erfährt nie davon, also wird sie nicht gespeichert und kein Server-Skript kann sie nutzen.
  • Jeder kann es fälschen. Wenn du das mit einem RemoteEvent wie AddItem(itemId, amount) löst, kann ein Exploiter dieses Event selbst feuern, mit beliebigen Argumenten, so oft er will. Der Security-Guide von Roblox sagt, dass der Server alles prüfen muss, was ein Client schickt, bevor er es benutzt.

Darum kann der Client in diesem Guide nur Anfragen zu Items stellen, die der Spieler schon besitzt: "rüste das aus" und "benutz das". Jede Anfrage enthält eine Item-ID und keine Anzahl und muss auf dem Server eine Prüfung bestehen: Ist es ein string, ist es ein echtes Item, besitzt der Spieler mindestens eins, und schickt der Spieler höchstens vier Anfragen pro Sekunde? Danach sucht der Server das Tool selbst aus dem Katalog heraus. Er nimmt vom Client nie ein Tool, einen Pfad oder eine Instanz an, wovor derselbe Guide warnt.

Items kommen nur über Server-Code hinein: ein Pickup, das der Server geprüft hat, ein Kauf, den der Server abgerechnet hat (der Shop-GUI-Guide baut einen), eine Quest-Belohnung oder ein Drop. Für das RemoteEvent-Muster allgemein, mit Prüfungen für andere Arten von Argumenten, lies den RemoteEvents-Guide.

Schritt 1: Den Explorer einrichten

Leg diese Objekte von Hand an. Die Skripte in den späteren Schritten finden sie über den Namen, also schreib jeden Namen genau so wie hier.

  1. Füge in ReplicatedStorage einen Folder namens InventoryRemotes ein. Füge darin drei RemoteEvents namens InventoryUpdated, EquipItem und UseItem ein.
  2. Füge in ServerStorage einen Folder namens ItemTools ein. Füge darin ein Tool namens Sword ein, und in das Tool einen Part namens Handle (1 mal 4 mal 1 Studs reicht). Achte darauf, dass beim Handle Anchored aus ist: Roblox warnt, dass Charaktere feststecken, wenn sie ein Tool mit verankerten Parts halten. Ein Tool, das du schon hast, geht auch, solange sein Name zum Katalog in Schritt 2 passt.
  3. Füge die Skripte hinzu, wenn du beim jeweiligen Schritt bist. Der Baum zeigt, wohin jedes gehört.
Der Explorer nach diesem Guide
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

Schritt 2: Deine Items in einem Katalog auflisten

Der Katalog beschreibt jedes Item, das es geben kann, genau einmal. Inventare speichern dann nur die ID eines Items und eine Anzahl. Das hält Speicherstände klein, und du kannst ein Item später umbenennen oder seine Beschreibung neu schreiben, ohne die gespeicherten Daten von irgendwem anzufassen.

Füge ein ModuleScript in ReplicatedStorage ein, nenn es ItemCatalog und ersetz seinen Inhalt durch das hier:

ModuleScript in ReplicatedStorage namens ItemCatalog
-- Jedes Item, das es im Spiel geben kann. Der Server und jeder Client lesen diese
-- Liste; nur der Server entscheidet, wem was gehört.
export type Item = {
	id: string, -- muss zum Schlüssel unten passen
	name: string,
	description: string,
	maxStack: number, -- wie viele von diesem Item höchstens in einen Slot passen
	icon: string?, -- optionales Bild, geschrieben als "rbxassetid://" plus die ID deines Bildes
	toolName: string?, -- ein Tool in ServerStorage.ItemTools: Das Item lässt sich ausrüsten
	heal: number?, -- Leben, das beim Benutzen zurückkommt: Das Item ist ein Verbrauchsgegenstand
}

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 = {}

-- Gibt das Item mit dieser ID zurück, oder nil, wenn es kein solches Item gibt
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Die optionalen Felder legen fest, was ein Item macht. toolName macht es ausrüstbar, heal macht es benutzbar, und ein Item ohne beides, wie Holz, bleibt im Inventar, bis anderer Server-Code (Crafting, Verkaufen) es entfernt.

Um ein Item hinzuzufügen, füge einen Eintrag hinzu, bei dem Schlüssel und id übereinstimmen. IDs unterscheiden Groß- und Kleinschreibung und werden gespeichert, also ändere eine ID nie, sobald Spieler das Item besitzen: Ändere stattdessen den name.

Schritt 3: Inventare auf dem Server halten

Dieses ModuleScript besitzt das Inventar jedes Spielers. Jedes Inventar ist eine Liste von Slots, jeder Slot eine Item-ID und eine Anzahl, dazu eine Kapazität von 20 Slots. Andere Server-Skripte rufen seine Funktionen auf, und sonst bearbeitet nichts die Tabelle.

Füge ein ModuleScript in ServerScriptService ein und nenn es InventoryService:

ModuleScript in ServerScriptService namens InventoryService
-- Der einzige Code, der Inventare ändert. Er liegt in ServerScriptService,
-- wo Clients ihn weder sehen noch ausführen können.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Der Strict-Modus kann einem require über WaitForChild nicht folgen, also geben wir
-- den Teil des Moduls an, den dieses Skript benutzt
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 -- Slots pro Spieler
local STARTER_ITEMS: { Slot } = { -- womit ein ganz neuer Spieler startet
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Schickt dem Besitzer eine Kopie seines Inventars. Läuft nach jeder Änderung.
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

-- Stapelregeln: Erst nicht volle Stapel auffüllen, dann neue Stapel in
-- leeren Slots anfangen. Gibt zurück, wie viele dazukamen, das kann weniger als verlangt sein.
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

-- Wie viele von einem Item noch passen: Platz in seinen Stapeln plus leere Slots
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

-- Fügt bis zu `amount` Stück eines Items hinzu. Gibt zurück, wie viele dazukamen (0, wenn
-- das Item nicht existiert, das Inventar voll ist oder noch nicht geladen hat).
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

-- Entfernt genau `amount` Stück eines Items, zuerst aus den letzten Stapeln.
-- Hat der Spieler weniger, wird nichts entfernt und false zurückgegeben.
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
	-- Rückwärts laufen, damit table.remove nie einen Slot überspringt
	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

-- Wird aufgerufen, sobald die gespeicherten Daten eines Spielers geladen sind. `saved` ist, was der Data
-- Store zurückgegeben hat: nil bei einem neuen Spieler. Jeder Eintrag läuft wieder durch die
-- Stapelregeln, also können entfernte Items und alte Stapelgrößen nichts kaputt machen.
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

-- Eine einfache Kopie zum Speichern, oder nil, wenn die Daten dieses Spielers nie geladen haben
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

Die type-Zeilen und der ::-Cast nach require helfen nur dem Type-Checker von Luau, der nicht sehen kann, was ein über WaitForChild gefundenes Modul zurückgibt. Beim Spielen ändern sie nichts. Die anderen Skripte in diesem Guide machen es genauso.

So wirken die Stapelregeln mit dem Katalog oben, in dem Äpfel bis 10 stapeln:

  • Fügst du einem Spieler mit einem Stapel von 7 Äpfeln 15 Äpfel hinzu, wird dieser Stapel auf 10 aufgefüllt und dann ein neuer Stapel mit 5 angefangen.
  • Wenn die Slots ausgehen, fügt add hinzu, was passt, und gibt diese Zahl zurück. Ruf vorher spaceFor auf, wenn es alles oder nichts sein muss, wie beim Pickup in Schritt 5.
  • remove ist alles oder nichts. Verlangst du 3 Äpfel von einem Spieler, der 2 hat, wird keiner entfernt und false zurückgegeben, also prüf das Ergebnis, bevor du im Tausch etwas hergibst.
  • Slots haben keine Lücken: Wird einer leer, rücken die anderen auf. So bleibt die Liste einfach zu schicken und zu speichern. Die Fragen am Ende behandeln Slots, die ihre Position behalten.
Was andere Server-Skripte aufrufen können
FunktionGibt zurückWofür
add(player, itemId, amount)Wie viele hinzugefügt wurdenPickups, Belohnungen, Käufe
remove(player, itemId, amount)true, wenn alle entfernt wurdenBenutzen, Verkaufen, Crafting
count(player, itemId)Die Summe über alle StapelPrüfen, was ein Spieler hat
spaceFor(player, itemId)Wie viele noch passen würdenPrüfen vor einem Hinzufügen nach dem Prinzip alles oder nichts
getEquipped, setEquippedDie ID des ausgerüsteten Items, oder nilAusrüsten, in Schritt 6
load, serialize, unloadEine Kopie zum Speichern (serialize)Laden und Speichern, in Schritt 4

Schritt 4: Jedes Inventar laden und speichern

Inventare liegen im Speicher des Servers, also sind sie weg, wenn der Spieler geht. Dieses Skript lädt die Slots eines Spielers aus einem Data Store, wenn er beitritt, und schreibt sie zurück, wenn er geht, wenn der Server herunterfährt und alle drei Minuten, falls der Server abstürzt. Es speichert nur Item-IDs und Anzahlen: Data Stores können keine Instanzen wie Tools speichern.

Füge ein Script in ServerScriptService ein und nenn es InventoryData:

Script in ServerScriptService namens 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

-- Gespeichert werden nur Spieler, deren gespeicherte Daten geladen haben. Auf ein fehlgeschlagenes Laden darf
-- nie ein Speichern folgen, sonst ersetzt das leere Inventar das echte.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Eine fehlgeschlagene Anfrage soll niemanden seine Items kosten, also ein paar Mal neu versuchen.
-- GetDataStore steht auch im pcall, damit eine Studio-Sitzung, die keine
-- Data Stores erreicht, eine Warnung bekommt, statt dieses Skript anzuhalten.
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 -- sie sind gegangen, während wir geladen haben
	end
	if ok then
		InventoryService.load(player, saved) -- saved ist nil bei einem neuen Spieler
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Heißt meistens, dass der Studio-Zugriff auf API-Dienste aus ist. Mit den
		-- Start-Items spielen, damit du testen kannst, sie aber nie speichern.
		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 -- ihre Daten haben nie geladen, also gibt es nichts, was sicher geschrieben werden kann
	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)

-- Wenn der Server herunterfährt, alle noch Anwesenden speichern, dann auf jedes
-- laufende Speichern warten, auch auf die, die PlayerRemoving gestartet hat
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Alle paar Minuten alle speichern, damit ein Server-Absturz Minuten kostet, keine ganze Sitzung
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Was das Skript macht, und warum:

  • Mit Standardwerten laden. Ein neuer Spieler hat keinen gespeicherten Wert, also gibt GetAsync nil zurück und er bekommt die Start-Items. Gespeicherte Slots laufen wieder durch die Stapelregeln, also kann ein Item, das du aus dem Katalog entfernt hast, oder eine kleinere maximale Stapelgröße das Laden nicht kaputt machen. Alles, was nicht mehr passt oder dessen ID nicht mehr im Katalog steht, fällt weg, und das nächste Speichern macht das dauerhaft, also behalte jede ID, die Spieler besitzen könnten, im Katalog.
  • Nach einem fehlgeschlagenen Laden nie speichern. Geschrieben werden nur Spieler in canSave. In einem Live-Server wird ein Spieler, dessen Daten nach drei Versuchen immer noch nicht laden, gebeten, neu beizutreten. In Studio bekommt er stattdessen nicht gespeicherte Start-Items, wegen der Wiederholungen ein paar Sekunden später. Das siehst du, bis das Spiel mit eingeschaltetem API-Zugriff veröffentlicht ist.
  • Beim Verlassen und beim Herunterfahren speichern. BindToClose speichert jeden, der noch im Server ist, und wartet auf Speichervorgänge, die schon laufen. Roblox gibt gebundenen Funktionen bis zu 30 Sekunden.
  • Innerhalb der Limits bleiben. Ein Schreibvorgang pro Spieler alle drei Minuten, plus einer beim Verlassen, liegt weit unter dem Standardbudget pro Server von 60 Schreibvorgängen pro Minute plus 40 für jeden Spieler (Stand der Dokumentation: 30. September 2026). Das Schlüsselmuster User_ folgt den Best Practices von Roblox, und die Benutzer-ID an SetAsync zu übergeben verknüpft die Daten mit diesem Spieler, was Roblox für Anfragen zum Löschen von Daten dringend empfiehlt.

Für ein kleines Spiel ist das eine solide Grundlage. Session Locking, das verhindert, dass ein Spieler, der schnell den Server wechselt, Daten lädt, bevor der alte Server sie gespeichert hat, und wann du UpdateAsync statt SetAsync nimmst, behandelt das DataStore-Tutorial.

Schritt 5: Items aus der Welt vergeben

Ein Pickup ist der einfachste Weg, wie Items in ein Inventar kommen: ein Part mit einem ProximityPrompt, das ein Item hinzufügt, wenn ein Spieler es benutzt. Das Skript hört auf dem Server auf sein Event Triggered, also wird das Item dort hinzugefügt, wo der Client nicht eingreifen kann.

  1. Füge einen Part in Workspace ein, nenn ihn Apple und färb ihn rot. Schalte Anchored ein und CanCollide aus, damit niemand dagegenstößt, während er unsichtbar ist. Der Prompt zeigt den Namen des Parts.
  2. Scroll bei ausgewähltem Part im Properties-Fenster zum Bereich Attributes und klick auf +. Füge ItemId mit dem Typ string hinzu, klick auf Save und setz den Wert auf apple. Füge Amount genauso als number mit dem Wert 1 hinzu.
  3. Füge ein Script in den Part ein, nenn es ItemPickup und füge diesen Code ein:
Script in dem Part Apple in Workspace namens ItemPickup
-- Leg dieses Script in einen Part und gib dem Part zwei Attribute:
-- ItemId (ein string, zum Beispiel apple) und Amount (eine number, zum Beispiel 1).
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 -- jemand anderes hat es gerade eben eingesammelt
	end
	-- Die Entfernung auf dem Server prüfen, statt der Anfrage zu vertrauen
	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 -- nicht genug Platz: das Pickup liegen lassen
	end
	InventoryService.add(player, itemId, amount)

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

Kopier den Part, um mehr Pickups zu platzieren. Ändere die Attribute, um Holz, ein weiteres Schwert oder einen Stapel Äpfel zu verteilen.

Roblox prüft bei Triggered die Entfernung, aber sein Security-Guide sagt trotzdem, dass du Prompts auf dem Server prüfen sollst: Ein Exploiter kann die Events eines Prompts feuern, auch wenn Enabled false ist, und kann einen nicht verankerten Part zu seinem Charakter ziehen. Darum prüft das Skript Enabled und die Entfernung selbst, und darum ist der Part verankert.

Jedes andere Server-Skript vergibt Items auf dieselbe Art. Nach einem Kauf, einer Quest oder einem Kill: require InventoryService wie die Skripte oben und ruf InventoryService.add(player, "wood", 5) auf. Prüf vorher spaceFor, wenn das Item nicht verloren gehen darf. Ein NPC kann eine weitere Quelle sein: Im NPC-Dialog-Guide führt eine Antwort eine Aktion auf dem Server aus, und diese Aktion kann InventoryService.add auf dieselbe Art aufrufen.

Schritt 6: Tools ausrüsten und Items benutzen

Zwei RemoteEvents tragen die einzigen Anfragen, die ein Client stellen kann. EquipItem legt eine Kopie des Tools des Items aus ServerStorage in den Backpack des Spielers (die Hotbar unten am Bildschirm) und in seine Hand, und eine erneute Anfrage nimmt es wieder weg. UseItem entfernt eins von einem benutzbaren Item und wendet seine Wirkung an, hier Heilen.

Füge ein Script in ServerScriptService ein und nenn es InventoryActions:

Script in ServerScriptService namens 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 } = {}

-- Jede Anfrage beginnt hier. Ein Client kann jederzeit alles schicken, also prüfen:
-- den Typ, dass das Item existiert, dass der Spieler eins besitzt, und die Rate.
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

-- Zerstört das Tool dieses Items überall, wo eine Kopie ist: Hotbar, Hand oder 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) -- immer nur ein ausgerüstetes Tool

	local tool = template:Clone()
	tool.CanBeDropped = false -- eine fallen gelassene Kopie könnte jemand anderes aufheben
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Eine zweite Kopie in StarterGear wird nach einem Respawn zurück in den Backpack kopiert
	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) -- direkt in die Hand geben
	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) -- ein erneuter Klick auf das ausgerüstete Item nimmt es wieder weg
	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 -- tot oder schon volles Leben: das Item nicht verschwenden
	end
	-- Zuerst das Item nehmen und nur heilen, wenn das geklappt hat
	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)
Was jede Anfrage darf
AnfrageDer Client schicktDer Server prüft, bevor er handelt
EquipItemEine Item-IDEs ist ein string, das Item existiert, der Spieler besitzt eins, Anfragen kommen nicht schneller als vier pro Sekunde, das Item hat einen toolName, und ein Tool mit diesem Namen liegt in ServerStorage.ItemTools
UseItemEine Item-IDDieselben Prüfungen von Typ, Besitz und Rate, das Item hat einen heal-Wert, der Charakter lebt und ist verletzt, und ein Item wurde entfernt, bevor es Leben gibt

Drei Details verhindern, dass ein Tool verdoppelt wird oder verloren geht. Bei der Kopie ist CanBeDropped auf false gesetzt, weil ein fallen gelassenes Tool in Workspace landet, wo ein anderer Spieler es nehmen könnte, während das Original im Inventar bleibt. Jede Kopie trägt ein Attribut InventoryItem, damit das Ablegen jede Kopie finden und zerstören kann, egal wo sie ist. Und wenn der Spieler einen Container StarterGear hat, kommt eine zweite Kopie dort hinein. Roblox kopiert StarterGear jedes Mal in den Backpack, wenn der Charakter spawnt, also kommt ein ausgerüstetes Schwert nach einem Respawn zurück.

Es ist immer nur ein Tool ausgerüstet, und was ausgerüstet ist, wird nicht gespeichert, also startet ein Spieler nach dem Wiederbeitreten mit leerer Hotbar. Wenn du später Verkaufen oder Fallenlassen hinzufügst, leg ein Item ab, bevor seine letzte Kopie das Inventar verlässt.

Aus dem Platzhalter-Sword kann eins werden, das wirklich kämpft: Bau das Tool aus dem Schwert-Guide, behalt den Namen Sword und leg es statt des Platzhalters in ItemTools. Das Server-Skript aus diesem Guide prüft dann jeden Schlag, egal wie der Spieler an das Schwert gekommen ist.

Schritt 7: Das Inventar-Grid zeichnen

Das LocalScript baut das ganze Fenster im Code, also musst du keine UI von Hand anordnen. Ein ScrollingFrame hält die Slots, ein UIGridLayout darin ordnet sie in Reihen an, und AutomaticCanvasSize vergrößert den Scrollbereich, wenn Reihen dazukommen.

Öffne im Explorer StarterPlayer, füge ein LocalScript in StarterPlayerScripts ein und nenn es InventoryClient:

LocalScript in StarterPlayerScripts namens 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. Das Fenster einmal bauen. ResetOnSpawn = false behält es über Respawns hinweg.
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 vergrößert es passend zu den Zellen
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. Eine Zelle pro Slot. Das zeichnet nur, was der Server geschickt hat; es ändert
-- das Inventar nie selbst.
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 -- ein leerer 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()
		-- Fragen, nie bestimmen: Der Server prüft die Anfrage und schickt das Ergebnis zurück
		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

-- Der Server feuert das nach dem Laden und nach jeder Änderung
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Mit dem Button oder der Taste B öffnen und schließen
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)

Ein LocalScript in StarterPlayerScripts läuft einmal pro Sitzung, und ResetOnSpawn = false behält die ScreenGui, wenn der Charakter respawnt, also zeigt das Grid weiter die letzte Kopie, die der Server geschickt hat.

Der Client zeichnet eine Zelle für jeden Slot, leere eingeschlossen, also sieht ein Inventar mit 20 Slots immer nach 20 Slots aus. Jedes Update zerstört die alten Zellen und baut neue, das ist einfach und reicht für ein paar Dutzend Slots. Feuert der Server InventoryUpdated, bevor dieses Skript sich damit verbunden hat, stellt Roblox die Nachricht in eine Warteschlange und liefert sie, sobald der Handler verbunden ist, also geht das erste Inventar nicht verloren.

Willst du das Fenster lieber in Studio gestalten? Bau eine ScreenGui mit einem Vorlage-Slot und Clone ihn in makeCell. Für Icons setz das icon eines Items im Katalog auf ein Bild, das du hochgeladen hast, und seine Zelle zeigt das Bild statt des Namens.

Das Inventar testen

  1. Drück auf Play. Öffne das Inventar mit dem Button links oder B: Ein neuer Spieler hat ein Sword und 3 Apples, und der Zähler zeigt 2 / 20 slots. Solange Studio keine Data Stores erreicht, erscheinen die Items erst nach ein paar Sekunden, nach Lade-Warnungen im Output, und werden nicht gespeichert.
  2. Klick auf das Sword. Es erscheint in deiner Hand und in der Hotbar, und sein Slot bekommt eine lila Umrandung. Klick noch einmal, um es wegzustecken.
  3. Geh zum Part Apple und benutz seinen Prompt. Der Apfelstapel steigt auf 4, und der Part verschwindet für 15 Sekunden.
  4. Um das Heilen zu testen, senk zuerst dein Leben. Stell den Schalter Client/Server auf Server, wähl im Explorer den Humanoid deines Charakters aus, setz Health auf 50, schalte zurück auf Client und klick auf einen Apple.
  5. Mit eingeschaltetem Studio-Zugriff auf API-Dienste: Stopp und spiel noch einmal. Der Apfel, den du eingesammelt hast, ist noch da. Wenn ein Laden oder Speichern fehlgeschlagen ist, steht das im Output.

Um es mit mehr als einem Spieler zu sehen, wähl bei den Testoptionen Server & Clients mit 2 Clients. Jeder Spieler sieht nur sein eigenes Inventar, während beide ein Schwert in der Hand des anderen sehen können.

Häufige Fehler und Lösungen

Die meisten Probleme zeigen sich im Output-Fenster als Warnung oder rote Fehlerzeile. Lies die erste: Spätere Fehler sind oft eine Folge davon.

Infinite yield possible bei einem Aufruf von WaitForChild

Ein Skript wartet auf ein Objekt, das es unter genau diesem Namen nicht gibt. Vergleich deinen Explorer mit dem Baum in Schritt 1: InventoryRemotes mit seinen drei RemoteEvents in ReplicatedStorage, ItemTools in ServerStorage und die beiden Module. Namen unterscheiden Groß- und Kleinschreibung. Der Guide zu Skript-Fehlern erklärt diese Warnung genauer.

Das Grid öffnet sich, bleibt aber leer

Der Client zeichnet nur, was der Server schickt. Schau im Output nach Warnungen Inventory load failed und prüf, dass InventoryData ein Script ist, kein LocalScript, in ServerScriptService, mit dem ModuleScript InventoryService daneben. Zeigt der Output einen Fehler Remote event invocation, hört auf dem Client nichts auf InventoryUpdated: Such nach einem früheren Fehler von InventoryClient.

Die Items werden jedes Mal zurückgesetzt, wenn ich in Studio spiele

Wenn der Output Inventory not loaded: playing with starter items that will not be saved meldet, ist das Spiel nicht veröffentlicht oder der Studio-Zugriff auf API-Dienste ist aus. Schalte ihn wie in Schritt 4 beschrieben ein, in einer Testkopie deines Spiels.

Ein Klick auf das Schwert macht nichts

Such im Output nach Cannot equip sword: Das Tool in ServerStorage.ItemTools muss genau so heißen wie toolName im Katalog. Ein Tool braucht außerdem einen Part namens Handle, damit man es halten kann, außer du setzt sein RequiresHandle auf false.

Der Pickup-Prompt erscheint, aber nichts wird hinzugefügt

Das Attribut ItemId muss genau zu einer Katalog-ID passen, auch in der Groß- und Kleinschreibung: apple, nicht Apple. Nichts wird hinzugefügt, solange das Inventar des Spielers noch lädt oder wenn nicht genug Platz für die ganze Menge ist.

Das Speichern schlägt fehl, nachdem ich geändert habe, was gespeichert wird

Data Stores nehmen einfache Daten an: strings, numbers, booleans und Tabellen daraus. Ein Tool, einen Part oder eine andere Instanz zu speichern schlägt fehl, oder der Wert wird als nil gespeichert. Speichere die Item-ID und die Anzahl und bau alles andere aus dem Katalog neu auf, wie serialize es macht.

Mit RoCode bauen

Wenn du das System lieber beschreibst, statt es von Hand zu verdrahten, kann RoCode es in dem Spiel bauen, das du offen hast. RoCode ist ein KI-Agent für Roblox Studio: Du beschreibst die Funktion in einem Webchat, und sein Studio-Plugin erstellt die Skripte und Objekte in deinem Explorer, statt dir Code zum Einfügen zu geben. Prompts kannst du auf Deutsch schreiben.

Du schreibst

Füge ein Inventar mit 20 Slots hinzu, das Items stapelt, ein Grid-UI, das sich mit B öffnet, ein Schwert aus ServerStorage, das Spieler ausrüsten können, Äpfel, die heilen, und Speichern mit DataStoreService.

RoCode macht
  • Kann dein Spiel durchsuchen, wenn ein Schritt es braucht, mit Search Game und Search Scripts, und so auf Items, Remotes oder Speichercode aufbauen, die du schon hast, statt ein zweites System hinzuzufügen
  • Erstellt die Ordner und RemoteEvents mit Create Instance, und die ModuleScripts, Scripts und das LocalScript mit Create Script
  • Kann das Fenster mit Build UI vorbereiten, das ein Inventar-Layout mit Platzhalter-Slots hat; der Code, der die Slots vom Server aus füllt, wird als eigene Skripte geschrieben
  • Prüft jedes Skript in Studio mit Check Script auf Kompilierfehler, was Kompilierfehler und ein paar riskante Muster findet, aber deinen Code weder auf Typen prüft noch lintet oder ausführt

Jede Änderungsrunde ist ein Undo-Punkt in Studio. RoCode kann den Studio-Zugriff auf API-Dienste nicht einschalten, das machst du selbst. Mit Plugin 3.9 oder neuer kann es einen kurzen Playtest machen und die Fehler lesen, und mit Plugin 3.9.15 oder neuer kann sein Test-Charakter Tasten drücken und Items ausrüsten, aber es prüft nur, was es selbst zum Testen ausgewählt hat, also teste das Speichern selbst. Ein Inventar baut auf anderen Systemen wie Speichern und Tools auf, und ein KI-Spielemacher, der in deinem eigenen Studio-Place baut, fügt sie Prompt für Prompt hinzu. Wie sich RoCode mit Studio verbindet.

Häufige Fragen

Soll ich statt eines eigenen Inventars den Backpack von Roblox benutzen?

Der Backpack ist das eingebaute Inventar von Roblox: Jedes Tool darin erscheint als Button in der Hotbar. Wenn jedes Item in deinem Spiel ein Tool ist und du keine Stapel, Anzahlen oder Slot-Grenze brauchst, kann er reichen, auch wenn du trotzdem speichern musst, welche Tools jeder Spieler besitzt. Ein eigenes Inventar ist für Items, die keine Tools sind, wie Materialien und Verbrauchsgegenstände. Dieser Guide nutzt beides: Das Inventar speichert alles, und der Backpack hält das Tool, das gerade ausgerüstet ist.

Kann ich die Standard-Hotbar ausblenden?

Ja. Ruf in einem LocalScript StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false) auf. Bei ausgeblendeter Hotbar brauchen Spieler einen anderen Weg, ein ausgerüstetes Tool zu halten und wegzustecken, zum Beispiel einen Button, der den Server bittet, Humanoid:EquipTool oder Humanoid:UnequipTools aufzurufen.

Wie behalten Slots ihre Position für Drag and Drop?

Speichere eine Liste fester Länge mit einem Eintrag pro Slot und markiere leere Slots mit einem Wert wie einer leeren ID statt nil, weil Roblox von nil-Werten in Tabellen abrät, die über ein RemoteEvent geschickt werden. Füge dann ein RemoteEvent MoveItem hinzu, das zwei Slot-Nummern schickt, und lass den Server prüfen, dass beide ganze Zahlen zwischen 1 und der Kapazität sind, bevor er sie tauscht.

Wie groß kann ein gespeichertes Inventar werden?

Ein Wert in einem Data Store kann nach dem Serialisieren bis zu 4.194.304 Zeichen lang sein (Stand der Dokumentation: 30. September 2026). Eine Liste aus IDs und Anzahlen braucht davon nur einen winzigen Teil. Text pro Item, wie eigene Namen oder lange Beschreibungen, die für jedes Item gespeichert werden, lässt einen Speicherstand wachsen.

Wie kaufe oder verkaufe ich Items für Coins?

Mach alles auf dem Server. Zum Verkaufen ruf InventoryService.remove auf und zahl nur aus, wenn es true zurückgegeben hat. Zum Kaufen prüf den Preis und spaceFor, zieh die Coins ab und ruf dann add auf. Der Shop-GUI-Guide baut die Kaufseite.

Quellen und weiterführende Links

So wurde der Code geprüft: Jedes Skript auf dieser Seite besteht die strikte Typprüfung von Luau mit den Roblox API-Definitionen (luau-lsp, 14. November 2026). Eine Typprüfung findet falsch geschriebene APIs und falsche Typen, aber keine Fehler in der Spiellogik. Teste also in Studio, bevor du veröffentlichst.

Probier RoCode in deinem eigenen Spiel aus.

Jeden Tag kostenlose Credits, ohne Karte. Installiere das Plugin, beschreibe das Feature und prüfe, was in Studio ankommt.